@revisium/formula 0.6.2 → 0.8.0

package/README.md

@@ -53,6 +53,31 @@ evaluate('max(max, 0)', { max: 10 });
 evaluate('max(max - field.min, 0)', { max: 100, field: { min: 20 } });
 // 80
 
+// AST serialization (inverse of parseFormula)
+import { parseFormula, serializeAst, replaceDependencies } from '@revisium/formula';
+
+serializeAst(parseFormula('(a + b) * 2').ast);
+// "(a + b) * 2"
+
+serializeAst(parseFormula('a + b * 2').ast);
+// "a + b * 2" (no unnecessary parentheses)
+
+serializeAst(parseFormula('items[*].price').ast);
+// "items[*].price"
+
+// Dependency replacement
+
+const ast = parseFormula('price * quantity + 10').ast;
+const newAst = replaceDependencies(ast, { price: 'cost', quantity: 'qty' });
+serializeAst(newAst);
+// "cost * qty + 10"
+
+// Replace with different path types
+const ast2 = parseFormula('items[*].price * 2').ast;
+const newAst2 = replaceDependencies(ast2, { 'items[*].price': 'products[*].cost' });
+serializeAst(newAst2);
+// "products[*].cost * 2"
+
 // Type inference
 import { inferFormulaType } from '@revisium/formula';
 
@@ -93,6 +118,8 @@ evaluateWithContext('price * (1 - ../discount)', {
 | `evaluate` | Evaluate expression with context |
 | `evaluateWithContext` | Evaluate with automatic `/` and `../` path resolution |
 | `inferFormulaType` | Infer return type of expression |
+| `serializeAst` | Serialize AST back to expression string (inverse of `parseFormula`) |
+| `replaceDependencies` | Replace dependency paths in AST (returns new AST) |
 
 ### Expression API
 

package/dist/{chunk-QS3FBYM5.cjs → chunk-4FIOGFOL.cjs}

@@ -89,6 +89,7 @@ var grammarText = String.raw`Formula {
   // Primary expressions
   Primary
     = "(" Expression ")"              -- paren
+    | "[" string "]"                  -- bracketedField
     | number
     | string
     | boolean
@@ -146,6 +147,9 @@ var grammarText = String.raw`Formula {
 var grammar2 = ohm__namespace.grammar(grammarText);
 
 // src/ohm/semantics/index.ts
+function isSafePropertyName(name) {
+  return name !== "__proto__";
+}
 function childrenToAST(children) {
   return children.filter((c) => "toAST" in c).map((c) => c.toAST());
 }
@@ -319,10 +323,18 @@ semantics.addOperation("toAST", {
     };
   },
   Postfix_index(obj, _lb, index, _rb) {
+    const indexAST = index.toAST();
+    if (indexAST.type === "StringLiteral") {
+      return {
+        type: "BracketedMemberExpression",
+        object: obj.toAST(),
+        property: indexAST.value
+      };
+    }
     return {
       type: "IndexExpression",
       object: obj.toAST(),
-      index: index.toAST()
+      index: indexAST
     };
   },
   Postfix_wildcard(obj, _lb, _star, _rb) {
@@ -342,6 +354,10 @@ semantics.addOperation("toAST", {
   Primary_paren(_lp, expr, _rp) {
     return expr.toAST();
   },
+  Primary_bracketedField(_lb, str, _rb) {
+    const strAST = str.toAST();
+    return { type: "BracketedIdentifier", name: strAST.value };
+  },
   Primary(e) {
     return e.toAST();
   },
@@ -397,6 +413,9 @@ semantics.addOperation("dependencies", {
   identifier(_start, _rest) {
     return [this.sourceString];
   },
+  Primary_bracketedField(_lb, _str, _rb) {
+    return [this.sourceString];
+  },
   rootPath(_slash, _path) {
     return [this.sourceString];
   },
@@ -419,7 +438,15 @@ semantics.addOperation("dependencies", {
   Postfix_index(obj, _lb, index, _rb) {
     const objDeps = obj.dependencies();
     const indexNode = index.toAST();
-    const getNumericIndex = (node) => {
+    if (indexNode.type === "StringLiteral") {
+      const strValue = indexNode.value;
+      const quote = this.sourceString.includes('"') ? '"' : "'";
+      if (objDeps.length === 1) {
+        return [`${objDeps[0]}[${quote}${strValue}${quote}]`];
+      }
+      return objDeps;
+    }
+    const getNumericIndex2 = (node) => {
       if (node.type === "NumberLiteral") {
         return node.value;
       }
@@ -428,7 +455,7 @@ semantics.addOperation("dependencies", {
       }
       return null;
     };
-    const numericIndex = getNumericIndex(indexNode);
+    const numericIndex = getNumericIndex2(indexNode);
     if (objDeps.length === 1 && numericIndex !== null) {
       return [`${objDeps[0]}[${numericIndex}]`];
     }
@@ -488,6 +515,9 @@ var ARRAY_FUNCTIONS = /* @__PURE__ */ new Set([
   "includes"
 ]);
 semantics.addOperation("features", {
+  Primary_bracketedField(_lb, _str, _rb) {
+    return ["bracket_notation"];
+  },
   rootPath(_slash, _path) {
     const path = this.sourceString;
     const features = ["root_path"];
@@ -518,6 +548,10 @@ semantics.addOperation("features", {
   Postfix_index(obj, _lb, index, _rb) {
     const objFeatures = obj.features();
     const indexFeatures = index.features();
+    const indexNode = index.toAST();
+    if (indexNode.type === "StringLiteral") {
+      return [...objFeatures, ...indexFeatures, "bracket_notation"];
+    }
     return [...objFeatures, ...indexFeatures, "array_index"];
   },
   Postfix_wildcard(obj, _lb, _star, _rb) {
@@ -727,10 +761,17 @@ semantics.addOperation("eval(ctx)", {
   Postfix_index(obj, _lb, index, _rb) {
     const objVal = obj.eval(this.args.ctx);
     const idx = index.eval(this.args.ctx);
-    if (idx < 0) {
-      return objVal?.[objVal.length + idx];
+    if (typeof idx === "string") {
+      if (!isSafePropertyName(idx)) {
+        return void 0;
+      }
+      return objVal?.[idx];
     }
-    return objVal?.[idx];
+    const numIdx = idx;
+    if (numIdx < 0) {
+      return objVal?.[objVal.length + numIdx];
+    }
+    return objVal?.[numIdx];
   },
   Postfix_wildcard(obj, _lb, _star, _rb) {
     return obj.eval(this.args.ctx);
@@ -747,6 +788,13 @@ semantics.addOperation("eval(ctx)", {
   Primary_paren(_lp, expr, _rp) {
     return expr.eval(this.args.ctx);
   },
+  Primary_bracketedField(_lb, str, _rb) {
+    const fieldName = str.eval(this.args.ctx);
+    if (!isSafePropertyName(fieldName)) {
+      return void 0;
+    }
+    return this.args.ctx[fieldName];
+  },
   Primary(e) {
     return e.eval(this.args.ctx);
   },
@@ -1161,6 +1209,272 @@ function inferFormulaType(expression, fieldTypes = {}) {
   }
 }
 
+// src/ohm/core/serialize-ast.ts
+function escapeDoubleQuoted(value) {
+  let result = "";
+  for (const char of value) {
+    switch (char) {
+      case "\\":
+        result += String.raw`\\`;
+        break;
+      case '"':
+        result += String.raw`\"`;
+        break;
+      case "\n":
+        result += String.raw`\n`;
+        break;
+      case "\r":
+        result += String.raw`\r`;
+        break;
+      case "	":
+        result += String.raw`\t`;
+        break;
+      default:
+        result += char;
+    }
+  }
+  return result;
+}
+var PRECEDENCE = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  ">": 4,
+  "<": 4,
+  ">=": 4,
+  "<=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6
+};
+function serializeBinaryOp(node) {
+  const prec = PRECEDENCE[node.op] ?? 0;
+  const wrapLeft = (child) => {
+    const s = serializeNode(child);
+    if (child.type === "BinaryOp") {
+      const childPrec = PRECEDENCE[child.op] ?? 0;
+      if (childPrec < prec) {
+        return `(${s})`;
+      }
+    }
+    if (child.type === "TernaryOp") {
+      return `(${s})`;
+    }
+    return s;
+  };
+  const wrapRight = (child) => {
+    const s = serializeNode(child);
+    if (child.type === "BinaryOp") {
+      const childPrec = PRECEDENCE[child.op] ?? 0;
+      if (childPrec <= prec) {
+        return `(${s})`;
+      }
+    }
+    if (child.type === "TernaryOp") {
+      return `(${s})`;
+    }
+    return s;
+  };
+  return `${wrapLeft(node.left)} ${node.op} ${wrapRight(node.right)}`;
+}
+function serializeNode(node) {
+  switch (node.type) {
+    case "NumberLiteral":
+      return String(node.value);
+    case "StringLiteral":
+      return `"${escapeDoubleQuoted(node.value)}"`;
+    case "BooleanLiteral":
+      return String(node.value);
+    case "NullLiteral":
+      return "null";
+    case "Identifier":
+      return node.name;
+    case "BracketedIdentifier":
+      return `["${escapeDoubleQuoted(node.name)}"]`;
+    case "RootPath":
+      return node.path;
+    case "RelativePath":
+      return node.path;
+    case "ContextToken":
+      return node.name;
+    case "BinaryOp":
+      return serializeBinaryOp(node);
+    case "UnaryOp":
+      return `${node.op}${serializeUnaryArgument(node)}`;
+    case "TernaryOp":
+      return `${serializeTernaryCondition(node.condition)} ? ${serializeNode(node.consequent)} : ${serializeNode(node.alternate)}`;
+    case "CallExpression":
+      return `${serializeNode(node.callee)}(${node.arguments.map(serializeNode).join(", ")})`;
+    case "MemberExpression":
+      return `${serializePostfixObject(node.object)}.${node.property}`;
+    case "BracketedMemberExpression":
+      return `${serializePostfixObject(node.object)}["${escapeDoubleQuoted(node.property)}"]`;
+    case "IndexExpression":
+      return `${serializePostfixObject(node.object)}[${serializeNode(node.index)}]`;
+    case "WildcardExpression":
+      return `${serializePostfixObject(node.object)}[*]`;
+  }
+}
+function serializeUnaryArgument(node) {
+  const s = serializeNode(node.argument);
+  if (node.argument.type === "BinaryOp" || node.argument.type === "TernaryOp") {
+    return `(${s})`;
+  }
+  return s;
+}
+function serializeTernaryCondition(node) {
+  const s = serializeNode(node);
+  if (node.type === "TernaryOp") {
+    return `(${s})`;
+  }
+  return s;
+}
+function serializePostfixObject(node) {
+  const s = serializeNode(node);
+  if (node.type === "BinaryOp" || node.type === "TernaryOp" || node.type === "UnaryOp") {
+    return `(${s})`;
+  }
+  return s;
+}
+function serializeAst(ast) {
+  return serializeNode(ast);
+}
+
+// src/ohm/core/replace-dependencies.ts
+function collectDependencyPath(node) {
+  switch (node.type) {
+    case "Identifier":
+      return node.name;
+    case "BracketedIdentifier":
+      return `["${node.name}"]`;
+    case "RootPath":
+      return node.path;
+    case "RelativePath":
+      return node.path;
+    case "MemberExpression": {
+      const objPath = collectDependencyPath(node.object);
+      if (objPath === null) {
+        return null;
+      }
+      return `${objPath}.${node.property}`;
+    }
+    case "BracketedMemberExpression": {
+      const objPath = collectDependencyPath(node.object);
+      if (objPath === null) {
+        return null;
+      }
+      const quote = '"';
+      return `${objPath}[${quote}${node.property}${quote}]`;
+    }
+    case "IndexExpression": {
+      const objPath = collectDependencyPath(node.object);
+      if (objPath === null) {
+        return null;
+      }
+      const numericIndex = getNumericIndex(node.index);
+      if (numericIndex !== null) {
+        return `${objPath}[${numericIndex}]`;
+      }
+      return null;
+    }
+    case "WildcardExpression": {
+      const objPath = collectDependencyPath(node.object);
+      if (objPath === null) {
+        return null;
+      }
+      return `${objPath}[*]`;
+    }
+    default:
+      return null;
+  }
+}
+function getNumericIndex(node) {
+  if (node.type === "NumberLiteral") {
+    return node.value;
+  }
+  if (node.type === "UnaryOp" && node.op === "-" && node.argument.type === "NumberLiteral") {
+    return -node.argument.value;
+  }
+  return null;
+}
+function findMatch(node, replacements) {
+  const fullPath = collectDependencyPath(node);
+  if (fullPath !== null) {
+    const value = replacements[fullPath];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return null;
+}
+function pathToAst(path) {
+  const { ast } = parseFormula(path);
+  return ast;
+}
+function replaceNode(node, replacements) {
+  const replacement = findMatch(node, replacements);
+  if (replacement !== null) {
+    return pathToAst(replacement);
+  }
+  switch (node.type) {
+    case "NumberLiteral":
+    case "StringLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "Identifier":
+    case "BracketedIdentifier":
+    case "RootPath":
+    case "RelativePath":
+    case "ContextToken":
+      return node;
+    case "BinaryOp":
+      return {
+        ...node,
+        left: replaceNode(node.left, replacements),
+        right: replaceNode(node.right, replacements)
+      };
+    case "UnaryOp":
+      return {
+        ...node,
+        argument: replaceNode(node.argument, replacements)
+      };
+    case "TernaryOp":
+      return {
+        ...node,
+        condition: replaceNode(node.condition, replacements),
+        consequent: replaceNode(node.consequent, replacements),
+        alternate: replaceNode(node.alternate, replacements)
+      };
+    case "CallExpression": {
+      const isSimpleFunctionCall = node.callee.type === "Identifier";
+      return {
+        ...node,
+        callee: isSimpleFunctionCall ? node.callee : replaceNode(node.callee, replacements),
+        arguments: node.arguments.map((arg) => replaceNode(arg, replacements))
+      };
+    }
+    case "MemberExpression":
+    case "BracketedMemberExpression":
+    case "WildcardExpression":
+      return {
+        ...node,
+        object: replaceNode(node.object, replacements)
+      };
+    case "IndexExpression":
+      return {
+        ...node,
+        object: replaceNode(node.object, replacements),
+        index: replaceNode(node.index, replacements)
+      };
+  }
+}
+function replaceDependencies(ast, replacements) {
+  return replaceNode(ast, replacements);
+}
+
 // src/parse-formula.ts
 function parseExpression(expression) {
   const result = parseFormula(expression);
@@ -1190,7 +1504,9 @@ exports.evaluateWithContext = evaluateWithContext;
 exports.inferFormulaType = inferFormulaType;
 exports.parseExpression = parseExpression;
 exports.parseFormula = parseFormula;
+exports.replaceDependencies = replaceDependencies;
+exports.serializeAst = serializeAst;
 exports.validateFormulaSyntax = validateFormulaSyntax;
 exports.validateSyntax = validateSyntax;
-//# sourceMappingURL=chunk-QS3FBYM5.cjs.map
-//# sourceMappingURL=chunk-QS3FBYM5.cjs.map
+//# sourceMappingURL=chunk-4FIOGFOL.cjs.map
+//# sourceMappingURL=chunk-4FIOGFOL.cjs.map