@codehz/json-expr 0.5.5 → 0.6.0

package/dist/index.mjs

@@ -333,27 +333,6 @@ function setProxyMetadata(proxy, metadata) {
 function getProxyMetadata(proxy) {
 	return proxyMetadata.get(proxy);
 }
-/**
-* 检查对象是否是 Proxy variable
-*/
-function isProxyVariable(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.get(obj)?.type === "variable";
-}
-/**
-* 检查对象是否是 Proxy expression
-*/
-function isProxyExpression(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.get(obj)?.type === "expression";
-}
-/**
-* 检查对象是否是任意 Proxy (variable 或 expression)
-*/
-function isProxy(obj) {
-	if (typeof obj !== "object" && typeof obj !== "function" || obj === null) return false;
-	return proxyMetadata.has(obj);
-}
 
 //#endregion
 //#region src/proxy-variable.ts
@@ -686,11 +665,10 @@ const ALLOWED_GLOBALS = new Set([
 * const sum = expr({ x, y })("x + y")
 * const result = expr({ sum, x })("sum * x")
 * const compiled = compile(result, { x, y })
-* // => [["x", "y"], "($0+$1)*$0"]
+* // => [["x", "y"], "($[0]+$[1])*$[0]"]
 * ```
 */
-function compile(expression, variables, options = {}) {
-	const { shortCircuit = true } = options;
+function compile(expression, variables, _options = {}) {
 	const ast = serializeArgumentToAST(expression);
 	const variableOrder = [];
 	const variableToIndex = /* @__PURE__ */ new Map();
@@ -708,13 +686,14 @@ function compile(expression, variables, options = {}) {
 		if (!name) return null;
 		const index = variableToIndex.get(name);
 		if (index === void 0) return null;
-		return `$${index}`;
+		return `$[${index}]`;
 	});
 	const undefinedVars = [];
 	const transformed = transformIdentifiers(placeholderTransformed, (name) => {
-		if (name.startsWith("$") && /^\$\d+$/.test(name)) return name;
+		if (name.startsWith("$[") && /^\$\[\d+\]$/.test(name)) return name;
+		if (/^_\d+$/.test(name)) return name;
 		const index = variableToIndex.get(name);
-		if (index !== void 0) return `$${index}`;
+		if (index !== void 0) return `$[${index}]`;
 		if (!ALLOWED_GLOBALS.has(name)) undefinedVars.push(name);
 		return name;
 	});
@@ -722,61 +701,142 @@ function compile(expression, variables, options = {}) {
 		const uniqueVars = [...new Set(undefinedVars)];
 		throw new Error(`Undefined variable(s): ${uniqueVars.join(", ")}`);
 	}
-	const expressions = [];
-	if (shortCircuit) {
-		let nextIndex = variableOrder.length;
-		function compileAst(node) {
-			if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node);
-			if (node.type === "ConditionalExpr") return compileConditional(node);
-			const exprStr = generate(node);
-			expressions.push(exprStr);
-			return nextIndex++;
-		}
-		function compileShortCircuit(node) {
-			const leftIdx = compileAst(node.left);
-			const branchConditions = {
-				"||": `$${leftIdx}`,
-				"&&": `!$${leftIdx}`,
-				"??": `$${leftIdx}!=null`
-			};
-			const branchIdx = expressions.length;
-			expressions.push([
-				"br",
-				branchConditions[node.operator],
-				0
-			]);
-			nextIndex++;
-			compileAst(node.right);
-			const skipCount = expressions.length - branchIdx - 1;
-			expressions[branchIdx][2] = skipCount;
-			const phiIdx = nextIndex++;
-			expressions.push(["phi"]);
-			return phiIdx;
-		}
-		function compileConditional(node) {
-			const testIdx = compileAst(node.test);
-			const branchIdx = expressions.length;
-			expressions.push([
-				"br",
-				`$${testIdx}`,
-				0
-			]);
-			nextIndex++;
-			compileAst(node.alternate);
-			const jmpIdx = expressions.length;
-			expressions.push(["jmp", 0]);
-			nextIndex++;
-			compileAst(node.consequent);
-			const thenEndIdx = expressions.length;
-			expressions[branchIdx][2] = jmpIdx - branchIdx;
-			expressions[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
-			const phiIdx = nextIndex++;
-			expressions.push(["phi"]);
-			return phiIdx;
-		}
-		compileAst(transformed);
-	} else expressions.push(generate(transformed));
-	return [variableOrder, ...expressions];
+	const topLevelExprs = [];
+	compileAst(transformed, {
+		nextParamIndex: 0,
+		expressionStack: [topLevelExprs],
+		nextIndex: variableOrder.length,
+		variableCount: variableOrder.length
+	});
+	return [variableOrder, ...topLevelExprs];
+}
+function currentExprs(ctx) {
+	return ctx.expressionStack[ctx.expressionStack.length - 1];
+}
+/**
+* 提取 AST 中所有 ArrowFunctionExpr 节点，编译为 FnNode，
+* 并将原始位置替换为 $[N] 标识符引用。
+*/
+function extractAndCompileArrowFunctions(node, ctx) {
+	switch (node.type) {
+		case "ArrowFunctionExpr": return {
+			type: "Identifier",
+			name: `$[${compileArrowFunction(node, ctx)}]`
+		};
+		case "BinaryExpr": return {
+			...node,
+			left: extractAndCompileArrowFunctions(node.left, ctx),
+			right: extractAndCompileArrowFunctions(node.right, ctx)
+		};
+		case "UnaryExpr": return {
+			...node,
+			argument: extractAndCompileArrowFunctions(node.argument, ctx)
+		};
+		case "ConditionalExpr": return {
+			...node,
+			test: extractAndCompileArrowFunctions(node.test, ctx),
+			consequent: extractAndCompileArrowFunctions(node.consequent, ctx),
+			alternate: extractAndCompileArrowFunctions(node.alternate, ctx)
+		};
+		case "MemberExpr": return {
+			...node,
+			object: extractAndCompileArrowFunctions(node.object, ctx),
+			property: node.computed ? extractAndCompileArrowFunctions(node.property, ctx) : node.property
+		};
+		case "CallExpr": return {
+			...node,
+			callee: extractAndCompileArrowFunctions(node.callee, ctx),
+			arguments: node.arguments.map((arg) => extractAndCompileArrowFunctions(arg, ctx))
+		};
+		case "ArrayExpr": return {
+			...node,
+			elements: node.elements.map((el) => extractAndCompileArrowFunctions(el, ctx))
+		};
+		case "ObjectExpr": return {
+			...node,
+			properties: node.properties.map((prop) => ({
+				...prop,
+				key: prop.computed ? extractAndCompileArrowFunctions(prop.key, ctx) : prop.key,
+				value: extractAndCompileArrowFunctions(prop.value, ctx)
+			}))
+		};
+		default: return node;
+	}
+}
+function compileAst(node, ctx) {
+	if (node.type === "BinaryExpr" && (node.operator === "||" || node.operator === "&&" || node.operator === "??")) return compileShortCircuit(node, ctx);
+	if (node.type === "ConditionalExpr") return compileConditional(node, ctx);
+	if (node.type === "ArrowFunctionExpr") return compileArrowFunction(node, ctx);
+	const exprStr = generate(extractAndCompileArrowFunctions(node, ctx));
+	currentExprs(ctx).push(exprStr);
+	return ctx.nextIndex++;
+}
+function compileShortCircuit(node, ctx) {
+	const exprs = currentExprs(ctx);
+	const leftIdx = compileAst(node.left, ctx);
+	const branchConditions = {
+		"||": `$[${leftIdx}]`,
+		"&&": `!$[${leftIdx}]`,
+		"??": `$[${leftIdx}]!=null`
+	};
+	const branchIdx = exprs.length;
+	exprs.push([
+		"br",
+		branchConditions[node.operator],
+		0
+	]);
+	ctx.nextIndex++;
+	compileAst(node.right, ctx);
+	const skipCount = exprs.length - branchIdx - 1;
+	exprs[branchIdx][2] = skipCount;
+	const phiIdx = ctx.nextIndex++;
+	exprs.push(["phi"]);
+	return phiIdx;
+}
+function compileConditional(node, ctx) {
+	const exprs = currentExprs(ctx);
+	const testIdx = compileAst(node.test, ctx);
+	const branchIdx = exprs.length;
+	exprs.push([
+		"br",
+		`$[${testIdx}]`,
+		0
+	]);
+	ctx.nextIndex++;
+	compileAst(node.alternate, ctx);
+	const jmpIdx = exprs.length;
+	exprs.push(["jmp", 0]);
+	ctx.nextIndex++;
+	compileAst(node.consequent, ctx);
+	const thenEndIdx = exprs.length;
+	exprs[branchIdx][2] = jmpIdx - branchIdx;
+	exprs[jmpIdx][1] = thenEndIdx - jmpIdx - 1;
+	const phiIdx = ctx.nextIndex++;
+	exprs.push(["phi"]);
+	return phiIdx;
+}
+function compileArrowFunction(node, ctx) {
+	const paramCount = node.params.length;
+	const fnIndex = ctx.nextIndex++;
+	const paramMapping = /* @__PURE__ */ new Map();
+	for (const param of node.params) if (param.type === "Placeholder") {
+		const paramName = `_${ctx.nextParamIndex++}`;
+		paramMapping.set(param.id, paramName);
+	}
+	const transformedBody = transformPlaceholders(node.body, (id) => {
+		return paramMapping.get(id) ?? null;
+	});
+	const lambdaStmts = [];
+	ctx.expressionStack.push(lambdaStmts);
+	compileAst(transformedBody, ctx);
+	ctx.expressionStack.pop();
+	const fnNode = [
+		"fn",
+		paramCount,
+		...lambdaStmts
+	];
+	currentExprs(ctx).push(fnNode);
+	return fnIndex;
 }
 
 //#endregion
@@ -786,10 +846,146 @@ function compile(expression, variables, options = {}) {
 */
 const evaluatorCache = /* @__PURE__ */ new Map();
 /**
-* 检测编译数据是否包含控制流节点（V2 格式）
+* 判断是否是 FnNode
+*/
+function isFnNode(expr) {
+	return Array.isArray(expr) && expr[0] === "fn" && typeof expr[1] === "number";
+}
+/**
+* 判断是否是控制流节点
+*/
+function isControlFlowNode(expr) {
+	return Array.isArray(expr) && (expr[0] === "br" || expr[0] === "jmp" || expr[0] === "phi");
+}
+/**
+* 生成 lambda 函数代码
+*
+* @param fnNode - FnNode 节点
+* @param indexCounter - 全局索引计数器
+* @param paramCounter - 参数计数器
+* @returns lambda 函数代码字符串
 */
-function isV2Format(expressions) {
-	return expressions.some((expr) => Array.isArray(expr));
+function generateLambdaCode(fnNode, indexCounter, paramCounter) {
+	const [, paramCount, ...stmts] = fnNode;
+	const paramStartIndex = paramCounter.value;
+	paramCounter.value += paramCount;
+	return `(${Array.from({ length: paramCount }, (_, i) => `_${paramStartIndex + i}`).join(",")})=>{${translateStmts(stmts, indexCounter, paramCounter)}}`;
+}
+/**
+* 翻译表达式列表为 JavaScript 代码
+* 使用全局索引计数器分配 $[N] 槽位
+*/
+function translateStmts(expressions, indexCounter, paramCounter) {
+	for (let i = 0; i < expressions.length; i++) {
+		const expr = expressions[i];
+		if (!expr) continue;
+		if (isControlFlowNode(expr)) {
+			const [type, , offset] = expr;
+			if ((type === "br" || type === "jmp") && offset !== void 0) {
+				const target = i + offset + 1;
+				if (target < 0 || target > expressions.length) throw new Error(`Unable to translate: invalid jump target at index ${i}. Target would be ${target}, but expression length is ${expressions.length}`);
+			}
+		}
+	}
+	const lines = ["let $lastValue;"];
+	const indexMap = [];
+	const savedStart = indexCounter.value;
+	for (let i = 0; i < expressions.length; i++) {
+		indexMap.push(indexCounter.value);
+		const expr = expressions[i];
+		if (isFnNode(expr)) {
+			indexCounter.value++;
+			countFnNodeIndices(expr, indexCounter);
+		} else indexCounter.value++;
+	}
+	indexCounter.value = savedStart;
+	const processed = /* @__PURE__ */ new Set();
+	function translateRange(start, end, indent = "") {
+		let i = start;
+		while (i < end) {
+			if (processed.has(i)) {
+				i++;
+				continue;
+			}
+			const expr = expressions[i];
+			if (!expr) {
+				i++;
+				continue;
+			}
+			const varIdx = indexMap[i];
+			if (isFnNode(expr)) {
+				processed.add(i);
+				indexCounter.value++;
+				const lambdaCode = generateLambdaCode(expr, indexCounter, paramCounter);
+				lines.push(`${indent}$[${varIdx}] = $lastValue = ${lambdaCode};`);
+				i++;
+			} else if (typeof expr === "string") {
+				processed.add(i);
+				indexCounter.value++;
+				lines.push(`${indent}$[${varIdx}] = $lastValue = ${expr};`);
+				i++;
+			} else if (!Array.isArray(expr)) i++;
+			else {
+				const [type] = expr;
+				if (type === "br") {
+					processed.add(i);
+					indexCounter.value++;
+					const [, condition, skipCount] = expr;
+					const falseBlockEnd = i + skipCount;
+					let jmpIdx = -1;
+					let trueBlockEnd = falseBlockEnd + 1;
+					if (falseBlockEnd < expressions.length) {
+						const lastInFalseBranch = expressions[falseBlockEnd];
+						if (Array.isArray(lastInFalseBranch) && lastInFalseBranch[0] === "jmp") {
+							jmpIdx = falseBlockEnd;
+							const jmpOffset = lastInFalseBranch[1];
+							trueBlockEnd = jmpIdx + jmpOffset;
+							processed.add(jmpIdx);
+						}
+					}
+					const hasElse = jmpIdx >= 0;
+					lines.push(`${indent}if (!(${condition})) {`);
+					translateRange(i + 1, falseBlockEnd + 1, indent + "  ");
+					if (hasElse) {
+						lines.push(`${indent}} else {`);
+						translateRange(jmpIdx + 1, trueBlockEnd + 1, indent + "  ");
+						lines.push(`${indent}}`);
+						i = trueBlockEnd + 1;
+					} else {
+						lines.push(`${indent}}`);
+						i = falseBlockEnd + 1;
+					}
+				} else if (type === "phi") {
+					processed.add(i);
+					indexCounter.value++;
+					lines.push(`${indent}$[${varIdx}] = $lastValue;`);
+					i++;
+				} else if (type === "jmp") {
+					indexCounter.value++;
+					throw new Error(`Unable to translate: unexpected jmp at index ${i}. This should have been paired with a preceding br. Unsupported control flow structure.`);
+				} else throw new Error(`Unable to translate: unknown control flow node type.`);
+			}
+		}
+	}
+	translateRange(0, expressions.length);
+	lines.push("return $lastValue;");
+	return lines.join("\n");
+}
+/**
+* 计算 FnNode 内部 stmts 占用的索引数量（递归）
+*/
+function countFnNodeIndices(fnNode, indexCounter) {
+	const [, , ...stmts] = fnNode;
+	for (const stmt of stmts) if (isFnNode(stmt)) {
+		indexCounter.value++;
+		countFnNodeIndices(stmt, indexCounter);
+	} else indexCounter.value++;
+}
+/**
+* 分析并验证控制流结构，将 br/jmp/phi 翻译为 if-else 语句
+*/
+function translateControlFlow(expressions, variableCount) {
+	return translateStmts(expressions, { value: variableCount }, { value: 0 });
 }
 /**
 * 执行编译后的表达式
@@ -803,7 +999,7 @@ function isV2Format(expressions) {
 *
 * @example
 * ```ts
-* const compiled = [["x", "y"], "$0+$1", "$1*2"]
+* const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
 * const result = evaluate<number>(compiled, { x: 2, y: 3 })
 * // => 6  (3 * 2)
 * ```
@@ -821,8 +1017,8 @@ function evaluate(data, values) {
 	const cacheKey = JSON.stringify(data);
 	let evaluator = evaluatorCache.get(cacheKey);
 	if (!evaluator) {
-		const functionBody = isV2Format(expressions) ? buildEvaluatorFunctionBodyV2(expressions, variableNames.length) : buildEvaluatorFunctionBody(expressions, variableNames.length);
-		evaluator = new Function("$values", functionBody);
+		const functionBody = buildEvaluatorFunctionBody(expressions, variableNames.length);
+		evaluator = new Function("$", functionBody);
 		evaluatorCache.set(cacheKey, evaluator);
 	}
 	try {
@@ -834,69 +1030,13 @@ function evaluate(data, values) {
 /**
 * 构造求值函数体
 *
-* @param expressions - 表达式列表
+* @param expressions - 表达式列表（可包含控制流节点和 FnNode）
 * @param variableCount - 变量数量
 * @returns 函数体字符串
-*
-* @example
-* ```ts
-* buildEvaluatorFunctionBody(["$0+$1", "$2*2"], 2)
-* // 返回执行 $0+$1 并存储到 $values[2]，然后执行 $2*2 的函数体
-* ```
 */
 function buildEvaluatorFunctionBody(expressions, variableCount) {
 	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	return [
-		...Array.from({ length: variableCount }, (_, i) => `const $${i} = $values[${i}];`),
-		...expressions.map((expr, i) => {
-			const idx = variableCount + i;
-			return `const $${idx} = ${expr}; $values[${idx}] = $${idx};`;
-		}),
-		`return $values[$values.length - 1];`
-	].join("\n");
-}
-/**
-* 构造带控制流支持的求值函数体（V2 格式）
-*
-* @param expressions - 表达式列表（可包含控制流节点）
-* @param variableCount - 变量数量
-* @returns 函数体字符串
-*/
-function buildEvaluatorFunctionBodyV2(expressions, variableCount) {
-	if (expressions.length === 0) throw new Error("No expressions to evaluate");
-	const lines = [
-		...Array.from({ length: variableCount }, (_, i) => `const $${i} = $values[${i}];`),
-		"let $pc = 0;",
-		"let $lastValue;",
-		...expressions.map((_, i) => `let $${variableCount + i};`),
-		`while ($pc < ${expressions.length}) {`,
-		"  switch ($pc) {"
-	];
-	expressions.forEach((expr, i) => {
-		const idx = variableCount + i;
-		lines.push(`    case ${i}: {`);
-		if (typeof expr === "string") {
-			lines.push(`      $${idx} = $lastValue = ${expr};`);
-			lines.push(`      $values[${idx}] = $${idx};`);
-			lines.push("      $pc++; break;");
-		} else {
-			const [type] = expr;
-			switch (type) {
-				case "br":
-					lines.push(`      if (${expr[1]}) { $pc += ${expr[2] + 1}; } else { $pc++; } break;`);
-					break;
-				case "jmp":
-					lines.push(`      $pc += ${expr[1] + 1}; break;`);
-					break;
-				case "phi":
-					lines.push(`      $${idx} = $values[${idx}] = $lastValue; $pc++; break;`);
-					break;
-			}
-		}
-		lines.push("    }");
-	});
-	lines.push("  }", "}", "return $values[$values.length - 1];");
-	return lines.join("\n");
+	return translateControlFlow(expressions, variableCount);
 }
 
 //#endregion
@@ -1682,5 +1822,5 @@ function wrap(value) {
 }
 
 //#endregion
-export { compile, compileAndEvaluate, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable, wrap };
+export { compile, compileAndEvaluate, evaluate, expr, lambda, t, variable, wrap };
 //# sourceMappingURL=index.mjs.map