exploreda 0.0.5 → 0.1.0

package/dist/chunk-SKXGYJJG.cjs

@@ -0,0 +1,370 @@
+'use strict';
+
+var ohm = require('ohm-js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ohm__namespace = /*#__PURE__*/_interopNamespace(ohm);
+
+// src/lib/calculations/parser/semantics.ts
+var grammarSource = `Calculation {
+  Expression = IfExpr | TernaryExpr | LogicalExpr
+
+  LogicalExpr = LogicalExpr "||" AndExpr  -- binary
+              | AndExpr                        -- term
+
+  AndExpr = AndExpr "&&" ComparisonExpr  -- binary
+          | ComparisonExpr              -- term
+
+  ComparisonExpr = ComparisonExpr ComparisonOp AddExpr  -- binary
+                 | AddExpr                              -- term
+
+  AddExpr = AddExpr ("+" | "-") MulExpr  -- binary
+         | MulExpr                       -- term
+
+  MulExpr = MulExpr ("*" | "/") PowerExpr  -- binary
+         | PowerExpr                       -- term
+
+  PowerExpr = Term "^" PowerExpr  -- binary
+           | Term                 -- term
+
+  TernaryExpr = LogicalExpr "?" Expression ":" Expression
+  Term = UnaryExpr | FunctionCall | ParenTerm | fieldReference | number | string | boolean | null | identifier
+  fieldReference = "[" string "]"
+  UnaryExpr = UnaryOperator Term
+  FunctionCall = identifier "(" ListOf<Expression, ","> ")"
+  ParenTerm = "(" Expression ")"
+  IfExpr = "if" Expression "then" Expression "else" Expression
+
+  ComparisonOp = "==" | "!=" | "<=" | ">=" | "<" | ">"
+  UnaryOperator = "-" | "+" | "!"
+
+  identifier = ~keyword (letter | "_") (letter | digit | "_")*
+  number = digit+ ("." digit+)?
+  string = "\\"" stringChar* "\\""
+  stringChar = ~("\\"" | "\\\\") any  -- nonEscape
+             | "\\\\" any              -- escape
+  boolean = ("true" | "false") ~(letter | digit | "_")
+  null = "null" ~(letter | digit | "_")
+
+  // Built-in keywords
+  keyword = ("if" | "then" | "else" | "true" | "false" | "null") ~(letter | digit | "_")
+
+  // Whitespace handling
+  space += comment
+  comment = "//" (~"\\n" any)* "\\n"  // Single line comments
+}`;
+var grammar2 = ohm__namespace.grammar(grammarSource);
+var semantics = grammar2.createSemantics();
+semantics.addOperation("eval", {
+  Expression(e) {
+    return e.eval();
+  },
+  LogicalExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  LogicalExpr_term(term) {
+    return term.eval();
+  },
+  AndExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  AndExpr_term(term) {
+    return term.eval();
+  },
+  ComparisonExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  ComparisonExpr_term(term) {
+    return term.eval();
+  },
+  AddExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  AddExpr_term(term) {
+    return term.eval();
+  },
+  MulExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  MulExpr_term(term) {
+    return term.eval();
+  },
+  PowerExpr_binary(left, op, right) {
+    return {
+      type: "basic",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      left: left.eval(),
+      right: right.eval()
+    };
+  },
+  PowerExpr_term(term) {
+    return term.eval();
+  },
+  LogicalExpr(expr) {
+    return expr.eval();
+  },
+  ComparisonExpr(expr) {
+    return expr.eval();
+  },
+  AddExpr(expr) {
+    return expr.eval();
+  },
+  MulExpr(expr) {
+    return expr.eval();
+  },
+  PowerExpr(expr) {
+    return expr.eval();
+  },
+  TernaryExpr(condition, _q, trueBranch, _c, falseBranch) {
+    return {
+      type: "ternary",
+      condition: condition.eval(),
+      trueBranch: trueBranch.eval(),
+      falseBranch: falseBranch.eval(),
+      expression: "?:",
+      name: `${condition.sourceString} ? ${trueBranch.sourceString} : ${falseBranch.sourceString}`
+    };
+  },
+  IfExpr(_if, condition, _then, trueBranch, _else, falseBranch) {
+    return {
+      type: "ternary",
+      condition: condition.eval(),
+      trueBranch: trueBranch.eval(),
+      falseBranch: falseBranch.eval(),
+      expression: "if",
+      name: `if ${condition.sourceString} then ${trueBranch.sourceString} else ${falseBranch.sourceString}`
+    };
+  },
+  UnaryExpr(op, expr) {
+    return {
+      type: "unary",
+      operator: op.sourceString,
+      expression: op.sourceString,
+      operand: expr.eval()
+    };
+  },
+  FunctionCall(name, _open, args, _close) {
+    return {
+      type: "function",
+      name: name.sourceString,
+      arguments: args.asIteration().children.map((arg) => arg.eval())
+    };
+  },
+  ParenTerm(_open, expr, _close) {
+    return expr.eval();
+  },
+  number(digits, _dot, decimals) {
+    return {
+      type: "literal",
+      value: parseFloat(this.sourceString),
+      expression: this.sourceString
+    };
+  },
+  string(_open, chars, _close) {
+    return {
+      type: "literal",
+      value: JSON.parse(this.sourceString),
+      expression: chars.sourceString
+    };
+  },
+  fieldReference(_open, field, _close) {
+    return {
+      type: "identifier",
+      name: field.eval().value,
+      expression: this.sourceString
+    };
+  },
+  boolean(_value) {
+    return {
+      type: "literal",
+      value: this.sourceString === "true",
+      expression: this.sourceString
+    };
+  },
+  null(_value) {
+    return {
+      type: "literal",
+      value: null,
+      expression: "null"
+    };
+  },
+  identifier(first, rest) {
+    return {
+      type: "identifier",
+      name: this.sourceString,
+      expression: this.sourceString
+    };
+  }
+});
+function parseExpression(input) {
+  const matchResult = grammar2.match(input);
+  if (matchResult.failed()) {
+    throw new Error(`Parse error: ${matchResult.message}`);
+  }
+  const parsed = semantics(matchResult).eval();
+  return convertToExpression(parsed, input);
+}
+function convertToExpression(parsed, rawInput) {
+  const id = crypto.randomUUID();
+  switch (parsed.type) {
+    case "basic":
+      if (!parsed.left || !parsed.right) {
+        throw new Error("Basic expression must have left and right operands");
+      }
+      return {
+        id,
+        type: "basic",
+        name: `${parsed.left?.name || ""} ${parsed.operator} ${parsed.right?.name || ""}`,
+        expression: parsed.operator || "",
+        dependencies: getDependencies(parsed),
+        left: convertToExpression(parsed.left, ""),
+        right: convertToExpression(parsed.right, ""),
+        operator: parsed.operator || "",
+        rawInput
+      };
+    case "unary":
+      if (!parsed.operand) {
+        throw new Error("Unary expression must have an operand");
+      }
+      return {
+        id,
+        type: "unary",
+        name: `${parsed.operator}${parsed.operand?.name || ""}`,
+        expression: parsed.operator || "",
+        dependencies: getDependencies(parsed),
+        operand: convertToExpression(parsed.operand, ""),
+        operator: parsed.operator || "",
+        rawInput
+      };
+    case "ternary":
+      if (!parsed.condition || !parsed.trueBranch || !parsed.falseBranch) {
+        throw new Error(
+          "Ternary expression must have condition and both branches"
+        );
+      }
+      return {
+        id,
+        type: "ternary",
+        name: parsed.name || `${parsed.condition?.name || ""} ? ${parsed.trueBranch?.name || ""} : ${parsed.falseBranch?.name || ""}`,
+        expression: parsed.expression || "?:",
+        dependencies: getDependencies(parsed),
+        condition: convertToExpression(parsed.condition, ""),
+        trueBranch: convertToExpression(parsed.trueBranch, ""),
+        falseBranch: convertToExpression(parsed.falseBranch, ""),
+        rawInput
+      };
+    case "function":
+      return {
+        id,
+        type: "function",
+        name: parsed.name || "",
+        expression: "",
+        functionName: parsed.name || "",
+        arguments: parsed.arguments?.map((arg) => convertToExpression(arg, "")) || [],
+        dependencies: getDependencies(parsed),
+        rawInput
+      };
+    case "identifier":
+      return {
+        id,
+        type: "literal",
+        name: parsed.name || "",
+        expression: parsed.name || "",
+        dependencies: [parsed.name || ""],
+        value: parsed.name || "",
+        rawInput
+      };
+    case "literal":
+      return {
+        id,
+        type: "literal",
+        name: String(parsed.value),
+        expression: String(parsed.value),
+        dependencies: [],
+        value: parsed.value,
+        rawInput
+      };
+    default:
+      throw new Error(`Unsupported expression type: ${parsed.type}`);
+  }
+}
+function getDependencies(parsed) {
+  const deps = /* @__PURE__ */ new Set();
+  function collect(expr) {
+    if (expr.type === "identifier") {
+      deps.add(expr.name || "");
+    }
+    if (expr.arguments) {
+      expr.arguments.forEach(collect);
+    }
+    if (expr.left) {
+      collect(expr.left);
+    }
+    if (expr.right) {
+      collect(expr.right);
+    }
+    if (expr.operand) {
+      collect(expr.operand);
+    }
+    if (expr.condition) {
+      collect(expr.condition);
+      collect(expr.trueBranch);
+      collect(expr.falseBranch);
+    }
+  }
+  collect(parsed);
+  return Array.from(deps);
+}
+var semantics_default = semantics;
+
+exports.parseExpression = parseExpression;
+exports.semantics_default = semantics_default;
+//# sourceMappingURL=chunk-SKXGYJJG.cjs.map
+//# sourceMappingURL=chunk-SKXGYJJG.cjs.map

package/dist/chunk-SKXGYJJG.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/calculations/parser/semantics.ts"],"names":["grammar","ohm"],"mappings":"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","file":"chunk-SKXGYJJG.cjs","sourcesContent":["import { type CalculationValue, type Expression } from \"../types\";\nimport * as ohm from \"ohm-js\";\n\n// Define the grammar inline\nconst grammarSource = `Calculation {\n  Expression = IfExpr | TernaryExpr | LogicalExpr\n\n  LogicalExpr = LogicalExpr \"||\" AndExpr  -- binary\n              | AndExpr                        -- term\n\n  AndExpr = AndExpr \"&&\" ComparisonExpr  -- binary\n          | ComparisonExpr              -- term\n\n  ComparisonExpr = ComparisonExpr ComparisonOp AddExpr  -- binary\n                 | AddExpr                              -- term\n\n  AddExpr = AddExpr (\"+\" | \"-\") MulExpr  -- binary\n         | MulExpr                       -- term\n\n  MulExpr = MulExpr (\"*\" | \"/\") PowerExpr  -- binary\n         | PowerExpr                       -- term\n\n  PowerExpr = Term \"^\" PowerExpr  -- binary\n           | Term                 -- term\n\n  TernaryExpr = LogicalExpr \"?\" Expression \":\" Expression\n  Term = UnaryExpr | FunctionCall | ParenTerm | fieldReference | number | string | boolean | null | identifier\n  fieldReference = \"[\" string \"]\"\n  UnaryExpr = UnaryOperator Term\n  FunctionCall = identifier \"(\" ListOf<Expression, \",\"> \")\"\n  ParenTerm = \"(\" Expression \")\"\n  IfExpr = \"if\" Expression \"then\" Expression \"else\" Expression\n\n  ComparisonOp = \"==\" | \"!=\" | \"<=\" | \">=\" | \"<\" | \">\"\n  UnaryOperator = \"-\" | \"+\" | \"!\"\n\n  identifier = ~keyword (letter | \"_\") (letter | digit | \"_\")*\n  number = digit+ (\".\" digit+)?\n  string = \"\\\\\"\" stringChar* \"\\\\\"\"\n  stringChar = ~(\"\\\\\"\" | \"\\\\\\\\\") any  -- nonEscape\n             | \"\\\\\\\\\" any              -- escape\n  boolean = (\"true\" | \"false\") ~(letter | digit | \"_\")\n  null = \"null\" ~(letter | digit | \"_\")\n\n  // Built-in keywords\n  keyword = (\"if\" | \"then\" | \"else\" | \"true\" | \"false\" | \"null\") ~(letter | digit | \"_\")\n\n  // Whitespace handling\n  space += comment\n  comment = \"//\" (~\"\\\\n\" any)* \"\\\\n\"  // Single line comments\n}`;\n\n// Create the grammar\nconst grammar = ohm.grammar(grammarSource);\n\nexport interface ParsedExpression {\n  type: string;\n  value?: CalculationValue;\n  children?: ParsedExpression[];\n  operator?: string;\n  left?: ParsedExpression;\n  right?: ParsedExpression;\n  name?: string;\n  arguments?: ParsedExpression[];\n  operand?: ParsedExpression;\n  condition?: ParsedExpression;\n  trueBranch?: ParsedExpression;\n  falseBranch?: ParsedExpression;\n  dependencies?: string[];\n  expression?: string;\n}\n\ntype Node = ohm.Node;\n\n// Create semantics\nconst semantics = grammar.createSemantics();\n\nsemantics.addOperation<ParsedExpression>(\"eval\", {\n  Expression(e: Node): ParsedExpression {\n    return e.eval();\n  },\n  LogicalExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  LogicalExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  AndExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  AndExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  ComparisonExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  ComparisonExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  AddExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  AddExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  MulExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  MulExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  PowerExpr_binary(left: Node, op: Node, right: Node): ParsedExpression {\n    return {\n      type: \"basic\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      left: left.eval(),\n      right: right.eval(),\n    };\n  },\n  PowerExpr_term(term: Node): ParsedExpression {\n    return term.eval();\n  },\n  LogicalExpr(expr: Node): ParsedExpression {\n    return expr.eval();\n  },\n  ComparisonExpr(expr: Node): ParsedExpression {\n    return expr.eval();\n  },\n  AddExpr(expr: Node): ParsedExpression {\n    return expr.eval();\n  },\n  MulExpr(expr: Node): ParsedExpression {\n    return expr.eval();\n  },\n  PowerExpr(expr: Node): ParsedExpression {\n    return expr.eval();\n  },\n  TernaryExpr(\n    condition: Node,\n    _q: Node,\n    trueBranch: Node,\n    _c: Node,\n    falseBranch: Node\n  ): ParsedExpression {\n    void _q;\n    void _c;\n    return {\n      type: \"ternary\",\n      condition: condition.eval(),\n      trueBranch: trueBranch.eval(),\n      falseBranch: falseBranch.eval(),\n      expression: \"?:\",\n      name: `${condition.sourceString} ? ${trueBranch.sourceString} : ${falseBranch.sourceString}`,\n    };\n  },\n  IfExpr(\n    _if: Node,\n    condition: Node,\n    _then: Node,\n    trueBranch: Node,\n    _else: Node,\n    falseBranch: Node\n  ): ParsedExpression {\n    void _if;\n    void _then;\n    void _else;\n    return {\n      type: \"ternary\",\n      condition: condition.eval(),\n      trueBranch: trueBranch.eval(),\n      falseBranch: falseBranch.eval(),\n      expression: \"if\",\n      name: `if ${condition.sourceString} then ${trueBranch.sourceString} else ${falseBranch.sourceString}`,\n    };\n  },\n  UnaryExpr(op: Node, expr: Node): ParsedExpression {\n    return {\n      type: \"unary\",\n      operator: op.sourceString,\n      expression: op.sourceString,\n      operand: expr.eval(),\n    };\n  },\n  FunctionCall(\n    name: Node,\n    _open: Node,\n    args: Node,\n    _close: Node\n  ): ParsedExpression {\n    void _open;\n    void _close;\n    return {\n      type: \"function\",\n      name: name.sourceString,\n      arguments: args.asIteration().children.map((arg: Node) => arg.eval()),\n    };\n  },\n  ParenTerm(_open: Node, expr: Node, _close: Node): ParsedExpression {\n    void _open;\n    void _close;\n    return expr.eval();\n  },\n  number(digits: Node, _dot: Node, decimals: Node): ParsedExpression {\n    void digits;\n    void _dot;\n    void decimals;\n    return {\n      type: \"literal\",\n      value: parseFloat(this.sourceString),\n      expression: this.sourceString,\n    };\n  },\n  string(_open: Node, chars: Node, _close: Node): ParsedExpression {\n    void _open;\n    void _close;\n    return {\n      type: \"literal\",\n      value: JSON.parse(this.sourceString),\n      expression: chars.sourceString,\n    };\n  },\n  fieldReference(_open: Node, field: Node, _close: Node): ParsedExpression {\n    return {\n      type: \"identifier\",\n      name: field.eval().value as string,\n      expression: this.sourceString,\n    };\n  },\n  boolean(_value: Node): ParsedExpression {\n    void _value;\n    return {\n      type: \"literal\",\n      value: this.sourceString === \"true\",\n      expression: this.sourceString,\n    };\n  },\n  null(_value: Node): ParsedExpression {\n    void _value;\n    return {\n      type: \"literal\",\n      value: null,\n      expression: \"null\",\n    };\n  },\n  identifier(first: Node, rest: Node): ParsedExpression {\n    void first;\n    void rest;\n    return {\n      type: \"identifier\",\n      name: this.sourceString,\n      expression: this.sourceString,\n    };\n  },\n});\n\nexport function parseExpression(input: string): Expression {\n  const matchResult = grammar.match(input);\n\n  if (matchResult.failed()) {\n    throw new Error(`Parse error: ${matchResult.message}`);\n  }\n\n  const parsed = semantics(matchResult).eval();\n\n  // Convert the parsed expression to our Expression type\n  return convertToExpression(parsed, input);\n}\n\nfunction convertToExpression(\n  parsed: ParsedExpression,\n  rawInput: string\n): Expression {\n  const id = crypto.randomUUID();\n\n  switch (parsed.type) {\n    case \"basic\":\n      if (!parsed.left || !parsed.right) {\n        throw new Error(\"Basic expression must have left and right operands\");\n      }\n      return {\n        id,\n        type: \"basic\",\n        name: `${parsed.left?.name || \"\"} ${parsed.operator} ${\n          parsed.right?.name || \"\"\n        }`,\n        expression: parsed.operator || \"\",\n        dependencies: getDependencies(parsed),\n        left: convertToExpression(parsed.left, \"\"),\n        right: convertToExpression(parsed.right, \"\"),\n        operator: parsed.operator || \"\",\n        rawInput,\n      };\n    case \"unary\":\n      if (!parsed.operand) {\n        throw new Error(\"Unary expression must have an operand\");\n      }\n      return {\n        id,\n        type: \"unary\",\n        name: `${parsed.operator}${parsed.operand?.name || \"\"}`,\n        expression: parsed.operator || \"\",\n        dependencies: getDependencies(parsed),\n        operand: convertToExpression(parsed.operand, \"\"),\n        operator: parsed.operator || \"\",\n        rawInput,\n      };\n    case \"ternary\":\n      if (!parsed.condition || !parsed.trueBranch || !parsed.falseBranch) {\n        throw new Error(\n          \"Ternary expression must have condition and both branches\"\n        );\n      }\n      return {\n        id,\n        type: \"ternary\",\n        name:\n          parsed.name ||\n          `${parsed.condition?.name || \"\"} ? ${\n            parsed.trueBranch?.name || \"\"\n          } : ${parsed.falseBranch?.name || \"\"}`,\n        expression: parsed.expression || \"?:\",\n        dependencies: getDependencies(parsed),\n        condition: convertToExpression(parsed.condition, \"\"),\n        trueBranch: convertToExpression(parsed.trueBranch, \"\"),\n        falseBranch: convertToExpression(parsed.falseBranch, \"\"),\n        rawInput,\n      };\n    case \"function\":\n      return {\n        id,\n        type: \"function\",\n        name: parsed.name || \"\",\n        expression: \"\",\n        functionName: parsed.name || \"\",\n        arguments:\n          parsed.arguments?.map((arg) => convertToExpression(arg, \"\")) || [],\n        dependencies: getDependencies(parsed),\n        rawInput,\n      };\n    case \"identifier\":\n      // Create a literal expression for identifiers instead of basic\n      return {\n        id,\n        type: \"literal\",\n        name: parsed.name || \"\",\n        expression: parsed.name || \"\",\n        dependencies: [parsed.name || \"\"],\n        value: parsed.name || \"\",\n        rawInput,\n      };\n    case \"literal\":\n      return {\n        id,\n        type: \"literal\",\n        name: String(parsed.value),\n        expression: String(parsed.value),\n        dependencies: [],\n        value: parsed.value,\n        rawInput,\n      };\n    default:\n      throw new Error(`Unsupported expression type: ${parsed.type}`);\n  }\n}\n\nfunction getDependencies(parsed: ParsedExpression): string[] {\n  const deps = new Set<string>();\n\n  function collect(expr: ParsedExpression) {\n    if (expr.type === \"identifier\") {\n      deps.add(expr.name || \"\");\n    }\n    if (expr.arguments) {\n      expr.arguments.forEach(collect);\n    }\n    if (expr.left) {\n      collect(expr.left);\n    }\n    if (expr.right) {\n      collect(expr.right);\n    }\n    if (expr.operand) {\n      collect(expr.operand);\n    }\n    if (expr.condition) {\n      collect(expr.condition);\n      collect(expr.trueBranch!);\n      collect(expr.falseBranch!);\n    }\n  }\n\n  collect(parsed);\n  return Array.from(deps);\n}\n\nexport default semantics;\n"]}