258 lines
7.7 KiB
JavaScript
258 lines
7.7 KiB
JavaScript
import jsyaml from '../../../libs/js-yaml.mjs';
|
||
|
||
const STATE_TAG_RE = /<\s*state\b[^>]*>([\s\S]*?)<\s*\/\s*state\s*>/gi;
|
||
|
||
export function extractStateBlocks(text) {
|
||
const s = String(text ?? '');
|
||
if (!s || s.toLowerCase().indexOf('<state') === -1) return [];
|
||
const out = [];
|
||
STATE_TAG_RE.lastIndex = 0;
|
||
let m;
|
||
while ((m = STATE_TAG_RE.exec(s)) !== null) {
|
||
const inner = String(m[1] ?? '');
|
||
if (inner.trim()) out.push(inner);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
export function computeStateSignature(text) {
|
||
const s = String(text ?? '');
|
||
if (!s || s.toLowerCase().indexOf('<state') === -1) return '';
|
||
const chunks = [];
|
||
STATE_TAG_RE.lastIndex = 0;
|
||
let m;
|
||
while ((m = STATE_TAG_RE.exec(s)) !== null) chunks.push(String(m[0] ?? '').trim());
|
||
return chunks.length ? chunks.join('\n---\n') : '';
|
||
}
|
||
|
||
/**
|
||
* 解析 <state> 块
|
||
* 返回: { rules: [{path, rule}], ops: [{path, op, value, ...}] }
|
||
*/
|
||
export function parseStateBlock(content) {
|
||
const lines = String(content ?? '').split(/\r?\n/);
|
||
|
||
const rules = [];
|
||
const dataLines = [];
|
||
|
||
// 第一遍：分离规则行和数据行
|
||
for (const line of lines) {
|
||
const trimmed = line.trim();
|
||
if (!trimmed || trimmed.startsWith('#')) continue;
|
||
|
||
// 规则行：以 $ 开头
|
||
if (trimmed.startsWith('$')) {
|
||
const parsed = parseRuleLineInternal(trimmed);
|
||
if (parsed) rules.push(parsed);
|
||
} else {
|
||
dataLines.push(line);
|
||
}
|
||
}
|
||
|
||
// 第二遍：解析数据
|
||
const ops = parseDataLines(dataLines);
|
||
|
||
return { rules, ops };
|
||
}
|
||
|
||
function parseRuleLineInternal(line) {
|
||
const tokens = line.trim().split(/\s+/);
|
||
const directives = [];
|
||
let pathStart = 0;
|
||
|
||
for (let i = 0; i < tokens.length; i++) {
|
||
if (tokens[i].startsWith('$')) {
|
||
directives.push(tokens[i]);
|
||
pathStart = i + 1;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
const path = tokens.slice(pathStart).join(' ').trim();
|
||
if (!path || !directives.length) return null;
|
||
|
||
const rule = {};
|
||
|
||
for (const tok of directives) {
|
||
if (tok === '$ro') { rule.ro = true; continue; }
|
||
if (tok === '$lock') { rule.lock = true; continue; }
|
||
|
||
const rangeMatch = tok.match(/^\$range=\[\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\]$/);
|
||
if (rangeMatch) {
|
||
rule.min = Math.min(Number(rangeMatch[1]), Number(rangeMatch[2]));
|
||
rule.max = Math.max(Number(rangeMatch[1]), Number(rangeMatch[2]));
|
||
continue;
|
||
}
|
||
|
||
const stepMatch = tok.match(/^\$step=(\d+(?:\.\d+)?)$/);
|
||
if (stepMatch) { rule.step = Math.abs(Number(stepMatch[1])); continue; }
|
||
|
||
const enumMatch = tok.match(/^\$enum=\{([^}]+)\}$/);
|
||
if (enumMatch) {
|
||
rule.enum = enumMatch[1].split(/[;；]/).map(s => s.trim()).filter(Boolean);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
return { path, rule };
|
||
}
|
||
|
||
function parseDataLines(lines) {
|
||
const results = [];
|
||
|
||
let pendingPath = null;
|
||
let pendingLines = [];
|
||
|
||
const flushPending = () => {
|
||
if (!pendingPath) return;
|
||
|
||
if (!pendingLines.length) {
|
||
results.push({ path: pendingPath, op: 'set', value: '' });
|
||
pendingPath = null;
|
||
pendingLines = [];
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const nonEmpty = pendingLines.filter(l => l.trim());
|
||
const minIndent = nonEmpty.length
|
||
? Math.min(...nonEmpty.map(l => l.search(/\S/)))
|
||
: 0;
|
||
|
||
const yamlText = pendingLines
|
||
.map(l => (l.trim() ? l.slice(minIndent) : ''))
|
||
.join('\n');
|
||
|
||
const obj = jsyaml.load(yamlText);
|
||
results.push({ path: pendingPath, op: 'set', value: obj });
|
||
} catch (e) {
|
||
results.push({ path: pendingPath, op: 'set', value: null, warning: `YAML 解析失败: ${e.message}` });
|
||
} finally {
|
||
pendingPath = null;
|
||
pendingLines = [];
|
||
}
|
||
};
|
||
|
||
for (const raw of lines) {
|
||
const trimmed = raw.trim();
|
||
if (!trimmed || trimmed.startsWith('#')) continue;
|
||
|
||
const indent = raw.search(/\S/);
|
||
|
||
if (indent === 0) {
|
||
flushPending();
|
||
const colonIdx = findTopLevelColon(trimmed);
|
||
if (colonIdx === -1) continue;
|
||
|
||
const path = trimmed.slice(0, colonIdx).trim();
|
||
const rhs = trimmed.slice(colonIdx + 1).trim();
|
||
if (!path) continue;
|
||
|
||
if (!rhs) {
|
||
pendingPath = path;
|
||
pendingLines = [];
|
||
} else {
|
||
results.push({ path, ...parseInlineValue(rhs) });
|
||
}
|
||
} else if (pendingPath) {
|
||
pendingLines.push(raw);
|
||
}
|
||
}
|
||
|
||
flushPending();
|
||
return results;
|
||
}
|
||
|
||
function findTopLevelColon(line) {
|
||
let inQuote = false;
|
||
let q = '';
|
||
let esc = false;
|
||
for (let i = 0; i < line.length; i++) {
|
||
const ch = line[i];
|
||
if (esc) { esc = false; continue; }
|
||
if (ch === '\\') { esc = true; continue; }
|
||
if (!inQuote && (ch === '"' || ch === "'")) { inQuote = true; q = ch; continue; }
|
||
if (inQuote && ch === q) { inQuote = false; q = ''; continue; }
|
||
if (!inQuote && ch === ':') return i;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
function unescapeString(s) {
|
||
return String(s ?? '')
|
||
.replace(/\\n/g, '\n')
|
||
.replace(/\\t/g, '\t')
|
||
.replace(/\\r/g, '\r')
|
||
.replace(/\\"/g, '"')
|
||
.replace(/\\'/g, "'")
|
||
.replace(/\\\\/g, '\\');
|
||
}
|
||
|
||
export function parseInlineValue(raw) {
|
||
const t = String(raw ?? '').trim();
|
||
|
||
if (t === 'null') return { op: 'del' };
|
||
|
||
// (负数) 强制 set
|
||
const parenNum = t.match(/^\((-?\d+(?:\.\d+)?)\)$/);
|
||
if (parenNum) return { op: 'set', value: Number(parenNum[1]) };
|
||
|
||
// +N / -N
|
||
if (/^\+\d/.test(t) || /^-\d/.test(t)) {
|
||
const n = Number(t);
|
||
if (Number.isFinite(n)) return { op: 'inc', delta: n };
|
||
}
|
||
|
||
// +"str"
|
||
const pushD = t.match(/^\+"((?:[^"\\]|\\.)*)"\s*$/);
|
||
if (pushD) return { op: 'push', value: unescapeString(pushD[1]) };
|
||
const pushS = t.match(/^\+'((?:[^'\\]|\\.)*)'\s*$/);
|
||
if (pushS) return { op: 'push', value: unescapeString(pushS[1]) };
|
||
|
||
// +[...]
|
||
if (t.startsWith('+[')) {
|
||
try {
|
||
const arr = JSON.parse(t.slice(1));
|
||
if (Array.isArray(arr)) return { op: 'push', value: arr };
|
||
} catch {}
|
||
return { op: 'set', value: t, warning: '+[] 解析失败' };
|
||
}
|
||
|
||
// -"str"
|
||
const popD = t.match(/^-"((?:[^"\\]|\\.)*)"\s*$/);
|
||
if (popD) return { op: 'pop', value: unescapeString(popD[1]) };
|
||
const popS = t.match(/^-'((?:[^'\\]|\\.)*)'\s*$/);
|
||
if (popS) return { op: 'pop', value: unescapeString(popS[1]) };
|
||
|
||
// -[...]
|
||
if (t.startsWith('-[')) {
|
||
try {
|
||
const arr = JSON.parse(t.slice(1));
|
||
if (Array.isArray(arr)) return { op: 'pop', value: arr };
|
||
} catch {}
|
||
return { op: 'set', value: t, warning: '-[] 解析失败' };
|
||
}
|
||
|
||
// 裸数字
|
||
if (/^-?\d+(?:\.\d+)?$/.test(t)) return { op: 'set', value: Number(t) };
|
||
|
||
// "str" / 'str'
|
||
const strD = t.match(/^"((?:[^"\\]|\\.)*)"\s*$/);
|
||
if (strD) return { op: 'set', value: unescapeString(strD[1]) };
|
||
const strS = t.match(/^'((?:[^'\\]|\\.)*)'\s*$/);
|
||
if (strS) return { op: 'set', value: unescapeString(strS[1]) };
|
||
|
||
if (t === 'true') return { op: 'set', value: true };
|
||
if (t === 'false') return { op: 'set', value: false };
|
||
|
||
// JSON array/object
|
||
if (t.startsWith('{') || t.startsWith('[')) {
|
||
try { return { op: 'set', value: JSON.parse(t) }; }
|
||
catch { return { op: 'set', value: t, warning: 'JSON 解析失败' }; }
|
||
}
|
||
|
||
// 兜底
|
||
return { op: 'set', value: t };
|
||
}
|