@elixpo/lixsketch 5.4.7 → 5.5.0

package/dist/react/chunk-HZWLPXFN.js

@@ -0,0 +1,198 @@
+"use client";
+
+// src/core/GraphMathParser.js
+var FUNCTIONS = {
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+  sqrt: Math.sqrt,
+  abs: Math.abs,
+  log: Math.log10,
+  ln: Math.log,
+  exp: Math.exp,
+  floor: Math.floor,
+  ceil: Math.ceil
+};
+var CONSTANTS = { pi: Math.PI, e: Math.E };
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if ("+-*/^(),".includes(ch)) {
+      tokens.push({ type: "op", value: ch });
+      i++;
+      continue;
+    }
+    if (/[0-9.]/.test(ch)) {
+      let num = "";
+      while (i < expr.length && /[0-9.]/.test(expr[i])) {
+        num += expr[i];
+        i++;
+      }
+      tokens.push({ type: "num", value: parseFloat(num) });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(ch)) {
+      let name = "";
+      while (i < expr.length && /[a-zA-Z_0-9]/.test(expr[i])) {
+        name += expr[i];
+        i++;
+      }
+      tokens.push({ type: "id", value: name });
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+}
+function insertImplicitMul(tokens) {
+  const result = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    result.push(t);
+    if (i + 1 < tokens.length) {
+      const next = tokens[i + 1];
+      const needsMul = (
+        // num followed by id or (  → 2x, 2(x), 2sin(x)
+        t.type === "num" && (next.type === "id" || next.value === "(") || // ) followed by ( or id or num → (x)(y), (x)2
+        t.value === ")" && (next.type === "num" || next.type === "id" || next.value === "(") || // id followed by ( when id is NOT a function → x(2) means x*2
+        t.type === "id" && next.value === "(" && !FUNCTIONS[t.value] || // id/num followed by id → xy means x*y
+        t.type === "id" && !FUNCTIONS[t.value] && next.type === "id" || // num followed by num after implicit patterns (rare)
+        t.type === "id" && !FUNCTIONS[t.value] && next.type === "num"
+      );
+      if (needsMul) {
+        result.push({ type: "op", value: "*" });
+      }
+    }
+  }
+  return result;
+}
+function parse(tokens) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function consume(expected) {
+    const t = tokens[pos];
+    if (expected && (!t || t.value !== expected)) return null;
+    pos++;
+    return t;
+  }
+  function parseExpr() {
+    let left = parseTerm();
+    while (peek() && (peek().value === "+" || peek().value === "-")) {
+      const op = consume().value;
+      const right = parseTerm();
+      const l = left, r = right;
+      if (op === "+") left = (x) => l(x) + r(x);
+      else left = (x) => l(x) - r(x);
+    }
+    return left;
+  }
+  function parseTerm() {
+    let left = parsePower();
+    while (peek() && (peek().value === "*" || peek().value === "/")) {
+      const op = consume().value;
+      const right = parsePower();
+      const l = left, r = right;
+      if (op === "*") left = (x) => l(x) * r(x);
+      else left = (x) => {
+        const d = r(x);
+        return d === 0 ? NaN : l(x) / d;
+      };
+    }
+    return left;
+  }
+  function parsePower() {
+    let base = parseUnary();
+    if (peek() && peek().value === "^") {
+      consume();
+      const exp = parsePower();
+      const b = base;
+      base = (x) => Math.pow(b(x), exp(x));
+    }
+    return base;
+  }
+  function parseUnary() {
+    if (peek() && peek().value === "-") {
+      consume();
+      const val = parsePrimary();
+      return (x) => -val(x);
+    }
+    if (peek() && peek().value === "+") {
+      consume();
+    }
+    return parsePrimary();
+  }
+  function parsePrimary() {
+    const t = peek();
+    if (!t) return () => NaN;
+    if (t.type === "num") {
+      consume();
+      const v = t.value;
+      return () => v;
+    }
+    if (t.value === "(") {
+      consume("(");
+      const inner = parseExpr();
+      consume(")");
+      return inner;
+    }
+    if (t.type === "id") {
+      consume();
+      const name = t.value.toLowerCase();
+      if (CONSTANTS[name] !== void 0) {
+        const v = CONSTANTS[name];
+        return () => v;
+      }
+      if (FUNCTIONS[name] && peek() && peek().value === "(") {
+        consume("(");
+        const arg = parseExpr();
+        consume(")");
+        const fn2 = FUNCTIONS[name];
+        return (x) => fn2(arg(x));
+      }
+      if (name === "x") return (x) => x;
+      return (x) => x;
+    }
+    consume();
+    return () => NaN;
+  }
+  const fn = parseExpr();
+  return fn;
+}
+function parseExpression(input) {
+  if (!input || typeof input !== "string") return null;
+  try {
+    let expr = input.trim();
+    expr = expr.replace(/^[yf]\s*\(?\s*x?\s*\)?\s*=\s*/i, "");
+    if (!expr) return null;
+    const tokens = tokenize(expr);
+    if (tokens.length === 0) return null;
+    const withMul = insertImplicitMul(tokens);
+    const fn = parse(withMul);
+    const test1 = fn(0);
+    const test2 = fn(1);
+    if (typeof test1 !== "number" && typeof test2 !== "number") return null;
+    return fn;
+  } catch (e) {
+    return null;
+  }
+}
+function isValidExpression(input) {
+  return parseExpression(input) !== null;
+}
+
+export {
+  parseExpression,
+  isValidExpression
+};
+//# sourceMappingURL=chunk-HZWLPXFN.js.map

package/dist/react/chunk-HZWLPXFN.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/GraphMathParser.js"],
+  "sourcesContent": ["/* eslint-disable */\n/**\n * GraphMathParser - Parses math expressions into evaluable functions.\n * Supports: +, -, *, /, ^ (power), implicit multiplication (2x, 3sin(x))\n * Functions: sin, cos, tan, asin, acos, atan, sqrt, abs, log, ln, exp, floor, ceil\n * Constants: pi, e\n * Forms: \"y = expr\", \"f(x) = expr\", or just \"expr\"\n */\n\nconst FUNCTIONS = {\n    sin: Math.sin, cos: Math.cos, tan: Math.tan,\n    asin: Math.asin, acos: Math.acos, atan: Math.atan,\n    sqrt: Math.sqrt, abs: Math.abs,\n    log: Math.log10, ln: Math.log, exp: Math.exp,\n    floor: Math.floor, ceil: Math.ceil,\n};\n\nconst CONSTANTS = { pi: Math.PI, e: Math.E };\n\n// Tokenizer\nfunction tokenize(expr) {\n    const tokens = [];\n    let i = 0;\n    while (i < expr.length) {\n        const ch = expr[i];\n        if (/\\s/.test(ch)) { i++; continue; }\n        if ('+-*/^(),'.includes(ch)) {\n            tokens.push({ type: 'op', value: ch });\n            i++;\n            continue;\n        }\n        // Number (including decimals)\n        if (/[0-9.]/.test(ch)) {\n            let num = '';\n            while (i < expr.length && /[0-9.]/.test(expr[i])) { num += expr[i]; i++; }\n            tokens.push({ type: 'num', value: parseFloat(num) });\n            continue;\n        }\n        // Identifier (variable, function, or constant)\n        if (/[a-zA-Z_]/.test(ch)) {\n            let name = '';\n            while (i < expr.length && /[a-zA-Z_0-9]/.test(expr[i])) { name += expr[i]; i++; }\n            tokens.push({ type: 'id', value: name });\n            continue;\n        }\n        i++; // skip unknown chars\n    }\n    return tokens;\n}\n\n// Insert implicit multiplication tokens\nfunction insertImplicitMul(tokens) {\n    const result = [];\n    for (let i = 0; i < tokens.length; i++) {\n        const t = tokens[i];\n        result.push(t);\n        if (i + 1 < tokens.length) {\n            const next = tokens[i + 1];\n            const needsMul =\n                // num followed by id or (  \u2192 2x, 2(x), 2sin(x)\n                (t.type === 'num' && (next.type === 'id' || next.value === '(')) ||\n                // ) followed by ( or id or num \u2192 (x)(y), (x)2\n                (t.value === ')' && (next.type === 'num' || next.type === 'id' || next.value === '(')) ||\n                // id followed by ( when id is NOT a function \u2192 x(2) means x*2\n                (t.type === 'id' && next.value === '(' && !FUNCTIONS[t.value]) ||\n                // id/num followed by id \u2192 xy means x*y\n                (t.type === 'id' && !FUNCTIONS[t.value] && next.type === 'id') ||\n                // num followed by num after implicit patterns (rare)\n                (t.type === 'id' && !FUNCTIONS[t.value] && next.type === 'num');\n            if (needsMul) {\n                result.push({ type: 'op', value: '*' });\n            }\n        }\n    }\n    return result;\n}\n\n// Recursive descent parser \u2192 builds evaluable function tree\nfunction parse(tokens) {\n    let pos = 0;\n\n    function peek() { return tokens[pos]; }\n    function consume(expected) {\n        const t = tokens[pos];\n        if (expected && (!t || t.value !== expected)) return null;\n        pos++;\n        return t;\n    }\n\n    // Expression: term ((+|-) term)*\n    function parseExpr() {\n        let left = parseTerm();\n        while (peek() && (peek().value === '+' || peek().value === '-')) {\n            const op = consume().value;\n            const right = parseTerm();\n            const l = left, r = right;\n            if (op === '+') left = (x) => l(x) + r(x);\n            else left = (x) => l(x) - r(x);\n        }\n        return left;\n    }\n\n    // Term: power ((*|/) power)*\n    function parseTerm() {\n        let left = parsePower();\n        while (peek() && (peek().value === '*' || peek().value === '/')) {\n            const op = consume().value;\n            const right = parsePower();\n            const l = left, r = right;\n            if (op === '*') left = (x) => l(x) * r(x);\n            else left = (x) => { const d = r(x); return d === 0 ? NaN : l(x) / d; };\n        }\n        return left;\n    }\n\n    // Power: unary (^ unary)*  (right-associative)\n    function parsePower() {\n        let base = parseUnary();\n        if (peek() && peek().value === '^') {\n            consume();\n            const exp = parsePower(); // right-associative\n            const b = base;\n            base = (x) => Math.pow(b(x), exp(x));\n        }\n        return base;\n    }\n\n    // Unary: (+|-) primary\n    function parseUnary() {\n        if (peek() && peek().value === '-') {\n            consume();\n            const val = parsePrimary();\n            return (x) => -val(x);\n        }\n        if (peek() && peek().value === '+') { consume(); }\n        return parsePrimary();\n    }\n\n    // Primary: number | variable | function(expr) | (expr)\n    function parsePrimary() {\n        const t = peek();\n        if (!t) return () => NaN;\n\n        // Number\n        if (t.type === 'num') {\n            consume();\n            const v = t.value;\n            return () => v;\n        }\n\n        // Parenthesized expression\n        if (t.value === '(') {\n            consume('(');\n            const inner = parseExpr();\n            consume(')');\n            return inner;\n        }\n\n        // Identifier\n        if (t.type === 'id') {\n            consume();\n            const name = t.value.toLowerCase();\n\n            // Constant\n            if (CONSTANTS[name] !== undefined) {\n                const v = CONSTANTS[name];\n                return () => v;\n            }\n\n            // Function call\n            if (FUNCTIONS[name] && peek() && peek().value === '(') {\n                consume('(');\n                const arg = parseExpr();\n                consume(')');\n                const fn = FUNCTIONS[name];\n                return (x) => fn(arg(x));\n            }\n\n            // Variable 'x'\n            if (name === 'x') return (x) => x;\n\n            // Unknown identifier \u2014 treat as x\n            return (x) => x;\n        }\n\n        // Fallback\n        consume();\n        return () => NaN;\n    }\n\n    const fn = parseExpr();\n    return fn;\n}\n\n/**\n * Parse a math expression string into a callable (x) => y function.\n * Returns null if parsing fails.\n */\nexport function parseExpression(input) {\n    if (!input || typeof input !== 'string') return null;\n\n    try {\n        let expr = input.trim();\n\n        // Strip \"y =\" or \"f(x) =\" prefix\n        expr = expr.replace(/^[yf]\\s*\\(?\\s*x?\\s*\\)?\\s*=\\s*/i, '');\n        if (!expr) return null;\n\n        const tokens = tokenize(expr);\n        if (tokens.length === 0) return null;\n\n        const withMul = insertImplicitMul(tokens);\n        const fn = parse(withMul);\n\n        // Validate: test with a few x values\n        const test1 = fn(0);\n        const test2 = fn(1);\n        if (typeof test1 !== 'number' && typeof test2 !== 'number') return null;\n\n        return fn;\n    } catch (e) {\n        return null;\n    }\n}\n\n/**\n * Validate an expression string \u2014 returns true if parseable.\n */\nexport function isValidExpression(input) {\n    return parseExpression(input) !== null;\n}\n"],
+  "mappings": "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",
+  "names": ["fn"]
+}