@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/text/text-helpers.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/functions/text/text-helpers.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellString,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { FormulaEngine } from \"src/core/engine\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * Strictly extracts string value without type coercion\n */\nexport function convertToString(result: FunctionEvaluationResult, context: EvaluationContext): string | ErrorEvaluationResult {\n  if (result.type === \"awaiting-evaluation\") {\n    return result;\n  }\n  \n  if (result.type !== \"value\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a value result\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (result.result.type === \"string\") {\n    return result.result.value;\n  } else {\n    // No type coercion - only strings are valid\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a string value\",\n      errAddress: context.dependencyNode,\n    };\n  }\n}\n\n/**\n * Strictly extracts numeric value without type coercion\n */\nexport function extractNumericValue(result: FunctionEvaluationResult, context: EvaluationContext): number | ErrorEvaluationResult {\n  if (result.type === \"awaiting-evaluation\") {\n    return result;\n  }\n  \n  if (result.type !== \"value\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a value result\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (result.result.type === \"number\") {\n    return result.result.value;\n  } else {\n    // No type coercion - only numbers are valid\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a number value\",\n      errAddress: context.dependencyNode,\n    };\n  }\n}\n\n/**\n * MID substring operation for MID function\n */\nexport function midOperation(\n  textResult: FunctionEvaluationResult,\n  startNumResult: FunctionEvaluationResult,\n  numCharsResult: FunctionEvaluationResult,\n  context: EvaluationContext\n): { type: \"value\"; result: CellString } | ErrorEvaluationResult {\n  const textStr = convertToString(textResult, context);\n  const startNum = extractNumericValue(startNumResult, context);\n  const numChars = extractNumericValue(numCharsResult, context);\n\n  // Check if any of the results are awaiting evaluation or errors\n  if (typeof textStr === \"object\" && (textStr.type === \"awaiting-evaluation\" || textStr.type === \"error\")) {\n    return textStr;\n  }\n  if (typeof startNum === \"object\" && (startNum.type === \"awaiting-evaluation\" || startNum.type === \"error\")) {\n    return startNum;\n  }\n  if (typeof numChars === \"object\" && (numChars.type === \"awaiting-evaluation\" || numChars.type === \"error\")) {\n    return numChars;\n  }\n\n  // At this point, all values should be primitive types\n  const textValue = textStr as string;\n  const startNumValue = startNum as number;\n  const numCharsValue = numChars as number;\n\n  // Validate startNum and numChars\n  if (startNumValue < 1) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"StartNum argument must be a positive number\",\n      errAddress: context.dependencyNode,\n    };\n  }\n  if (numCharsValue < 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"NumChars argument must be a positive number\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Convert to 0-based index (Excel uses 1-based)\n  const startIndex = Math.floor(startNumValue) - 1;\n  const length = Math.floor(numCharsValue);\n\n  // Extract substring\n  const result = textValue.substring(startIndex, startIndex + length);\n\n  return { type: \"value\", result: { type: \"string\", value: result } };\n}\n\n/**\n * Helper for creating spilled-values result for MID function (3 parameters)\n */\nexport function createMidSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResult,\n    startNumResult,\n    numCharsResult,\n    context,\n  }: {\n    textResult: FunctionEvaluationResult;\n    startNumResult: FunctionEvaluationResult;\n    numCharsResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): FunctionEvaluationResult {\n  const hasSpilledText = textResult.type === \"spilled-values\";\n  const hasSpilledStart = startNumResult.type === \"spilled-values\";\n  const hasSpilledNum = numCharsResult.type === \"spilled-values\";\n\n  if (!hasSpilledText && !hasSpilledStart && !hasSpilledNum) {\n    throw new Error(\"createMidSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress) => {\n      // Calculate spill area (union of all spilled ranges)\n      let spillArea: SpreadsheetRange;\n\n      if (hasSpilledText && textResult.type === \"spilled-values\") {\n        spillArea = textResult.spillArea(origin);\n      } else if (hasSpilledStart && startNumResult.type === \"spilled-values\") {\n        spillArea = startNumResult.spillArea(origin);\n      } else if (hasSpilledNum && numCharsResult.type === \"spilled-values\") {\n        spillArea = numCharsResult.spillArea(origin);\n      } else {\n        // This shouldn't happen since we check for spilled values at the beginning\n        throw new Error(\"No spilled values found\");\n      }\n\n      // Union with other spilled ranges if they exist\n      if (\n        hasSpilledText &&\n        hasSpilledStart &&\n        textResult.type === \"spilled-values\" &&\n        startNumResult.type === \"spilled-values\"\n      ) {\n        spillArea = this.unionRanges(\n          this.projectRange(textResult.spillArea(origin), origin),\n          this.projectRange(startNumResult.spillArea(origin), origin)\n        );\n      }\n\n      if (\n        (hasSpilledText || hasSpilledStart) &&\n        hasSpilledNum &&\n        numCharsResult.type === \"spilled-values\"\n      ) {\n        const projectedSpillArea = this.projectRange(spillArea, origin);\n        const numSpillArea = this.projectRange(\n          numCharsResult.spillArea(origin),\n          origin\n        );\n        spillArea = this.unionRanges(projectedSpillArea, numSpillArea);\n      }\n      return spillArea;\n    },\n    source: \"MID with spilled values\",\n    evaluate: (\n      spilledCell,\n      evalContext\n    ): SingleEvaluationResult => {\n      // Evaluate all arguments at this spilled position\n      const spillTextResult = hasSpilledText\n        ? textResult.evaluate(spilledCell, evalContext)\n        : textResult;\n      const spillStartResult = hasSpilledStart\n        ? startNumResult.evaluate(spilledCell, evalContext)\n        : startNumResult;\n      const spillNumResult = hasSpilledNum\n        ? numCharsResult.evaluate(spilledCell, evalContext)\n        : numCharsResult;\n\n      if (!spillTextResult || spillTextResult.type === \"error\") {\n        return spillTextResult;\n      }\n      if (!spillStartResult || spillStartResult.type === \"error\") {\n        return spillStartResult;\n      }\n      if (!spillNumResult || spillNumResult.type === \"error\") {\n        return spillNumResult;\n      }\n\n      return midOperation(spillTextResult, spillStartResult, spillNumResult, evalContext);\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\"WIP: evaluateAllCells for MID is not implemented\");\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "81F08635A25A4B9364756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/textjoin/textjoin.cjs

@@ -0,0 +1,173 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/text/textjoin/textjoin.ts
+var exports_textjoin = {};
+__export(exports_textjoin, {
+  TEXTJOIN: () => TEXTJOIN
+});
+module.exports = __toCommonJS(exports_textjoin);
+var import_types = require("src/core/types");
+var MAX_TEXT_LENGTH = 32767;
+function coerceToString(value) {
+  switch (value.type) {
+    case "string":
+      return value.value;
+    case "number":
+      if (value.value === Infinity) {
+        return "INFINITY";
+      } else if (value.value === -Infinity) {
+        return "-INFINITY";
+      } else if (isNaN(value.value)) {
+        return "NaN";
+      } else {
+        return value.value.toString();
+      }
+    case "boolean":
+      return value.value ? "TRUE" : "FALSE";
+    case "infinity":
+      return value.sign === "positive" ? "INFINITY" : "-INFINITY";
+    default:
+      return "";
+  }
+}
+function collectTextItems(args, ignoreEmpty, context) {
+  const textItems = [];
+  for (const arg of args) {
+    if (arg.type === "error") {
+      return arg;
+    }
+    if (arg.type === "value") {
+      const text = coerceToString(arg.result);
+      if (!ignoreEmpty || text !== "") {
+        textItems.push(text);
+      }
+    } else if (arg.type === "spilled-values") {
+      const cellValues = arg.evaluateAllCells.call(this, {
+        context,
+        origin: context.cellAddress,
+        evaluate: arg.evaluate,
+        lookupOrder: "col-major"
+      });
+      if (cellValues.type !== "values") {
+        return cellValues;
+      }
+      for (const cellValue of cellValues.values) {
+        if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+          return cellValue.result;
+        }
+        if (cellValue.result.type === "value") {
+          const text = coerceToString(cellValue.result.result);
+          if (!ignoreEmpty || text !== "") {
+            textItems.push(text);
+          }
+        }
+      }
+    }
+  }
+  return textItems;
+}
+var TEXTJOIN = {
+  name: "TEXTJOIN",
+  evaluate: function(node, context) {
+    if (node.args.length < 3) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "TEXTJOIN function requires at least 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const delimiterResult = this.evaluateNode(node.args[0], context);
+    if (delimiterResult.type === "error") {
+      return delimiterResult;
+    }
+    if (delimiterResult.type === "awaiting-evaluation") {
+      return delimiterResult;
+    }
+    if (delimiterResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "TEXTJOIN delimiter must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const delimiter = coerceToString(delimiterResult.result);
+    const ignoreEmptyResult = this.evaluateNode(node.args[1], context);
+    if (ignoreEmptyResult.type === "error") {
+      return ignoreEmptyResult;
+    }
+    if (ignoreEmptyResult.type === "awaiting-evaluation") {
+      return ignoreEmptyResult;
+    }
+    if (ignoreEmptyResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "TEXTJOIN ignore_empty must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    let ignoreEmpty = false;
+    if (ignoreEmptyResult.result.type === "boolean") {
+      ignoreEmpty = ignoreEmptyResult.result.value;
+    } else if (ignoreEmptyResult.result.type === "number") {
+      ignoreEmpty = ignoreEmptyResult.result.value !== 0;
+    } else if (ignoreEmptyResult.result.type === "string") {
+      ignoreEmpty = ignoreEmptyResult.result.value !== "";
+    }
+    const textArgs = [];
+    for (let i = 2;i < node.args.length; i++) {
+      const result2 = this.evaluateNode(node.args[i], context);
+      if (result2.type === "error" || result2.type === "awaiting-evaluation") {
+        return result2;
+      }
+      textArgs.push(result2);
+    }
+    const textItems = collectTextItems.call(this, textArgs, ignoreEmpty, context);
+    if (!Array.isArray(textItems)) {
+      return textItems;
+    }
+    const result = textItems.join(delimiter);
+    if (result.length > MAX_TEXT_LENGTH) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `TEXTJOIN result exceeds ${MAX_TEXT_LENGTH} character limit`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return {
+      type: "value",
+      result: { type: "string", value: result }
+    };
+  }
+};
+
+//# debugId=A87D4DCDE3D2304764756E2164756E21

package/dist/cjs/functions/text/textjoin/textjoin.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/textjoin/textjoin.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type ErrorEvaluationResult,\n  type CellString,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\n\n/**\n * TEXTJOIN function - Joins text from multiple ranges and/or strings with a specified delimiter\n *\n * Usage: TEXTJOIN(delimiter, ignore_empty, text1, [text2], ...)\n *\n * delimiter: String to insert between text items (can be empty string \"\")\n * ignore_empty: If TRUE, empty cells/strings are ignored; if FALSE, they are included\n * text1, text2, ...: Text items to join (can be strings, ranges, or arrays)\n *\n * Examples:\n *   TEXTJOIN(\", \", TRUE, A1:A3) - joins A1, A2, A3 with \", \" separator, ignoring empty cells\n *   TEXTJOIN(\"-\", FALSE, \"a\", \"b\", \"c\") - returns \"a-b-c\"\n *   TEXTJOIN(\", \", TRUE, \"Red\", \"\", \"Blue\") - returns \"Red, Blue\" (empty string ignored)\n *\n * Note:\n * - Supports type coercion: numbers and booleans are converted to strings\n * - Returns #VALUE! if result exceeds 32,767 characters\n */\n\nconst MAX_TEXT_LENGTH = 32767;\n\n/**\n * Helper function to convert a cell value to string with type coercion\n */\nfunction coerceToString(value: CellValue): string {\n  switch (value.type) {\n    case \"string\":\n      return value.value;\n    case \"number\":\n      // Convert number to string\n      if (value.value === Infinity) {\n        return \"INFINITY\";\n      } else if (value.value === -Infinity) {\n        return \"-INFINITY\";\n      } else if (isNaN(value.value)) {\n        return \"NaN\";\n      } else {\n        return value.value.toString();\n      }\n    case \"boolean\":\n      // Convert boolean to string\n      return value.value ? \"TRUE\" : \"FALSE\";\n    case \"infinity\":\n      return value.sign === \"positive\" ? \"INFINITY\" : \"-INFINITY\";\n    default:\n      return \"\";\n  }\n}\n\n/**\n * Helper function to collect all text items from arguments, handling ranges\n */\nfunction collectTextItems(\n  this: FormulaEvaluator,\n  args: FunctionEvaluationResult[],\n  ignoreEmpty: boolean,\n  context: EvaluationContext\n): string[] | ErrorEvaluationResult {\n  const textItems: string[] = [];\n\n  for (const arg of args) {\n    if (arg.type === \"error\") {\n      return arg;\n    }\n\n    if (arg.type === \"value\") {\n      const text = coerceToString(arg.result);\n      if (!ignoreEmpty || text !== \"\") {\n        textItems.push(text);\n      }\n    } else if (arg.type === \"spilled-values\") {\n      // Extract all values from the range\n      const cellValues = arg.evaluateAllCells.call(this, {\n        context,\n        origin: context.cellAddress,\n        evaluate: arg.evaluate,\n        lookupOrder: \"col-major\",\n      });\n\n      if (cellValues.type !== \"values\") {\n        return cellValues;\n      }\n\n      for (const cellValue of cellValues.values) {\n        if (\n          cellValue.result.type === \"error\" ||\n          cellValue.result.type === \"awaiting-evaluation\"\n        ) {\n          return cellValue.result;\n        }\n        if (cellValue.result.type === \"value\") {\n          const text = coerceToString(cellValue.result.result);\n          if (!ignoreEmpty || text !== \"\") {\n            textItems.push(text);\n          }\n        }\n      }\n    }\n  }\n\n  return textItems;\n}\n\n/**\n * TEXTJOIN function implementation\n */\nexport const TEXTJOIN: FunctionDefinition = {\n  name: \"TEXTJOIN\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN function requires at least 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate delimiter (first argument)\n    const delimiterResult = this.evaluateNode(node.args[0]!, context);\n    if (delimiterResult.type === \"error\") {\n      return delimiterResult;\n    }\n    if (delimiterResult.type === \"awaiting-evaluation\") {\n      return delimiterResult;\n    }\n\n    // Delimiter must be a single value\n    if (delimiterResult.type === \"spilled-values\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN delimiter must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const delimiter = coerceToString(delimiterResult.result);\n\n    // Evaluate ignore_empty (second argument)\n    const ignoreEmptyResult = this.evaluateNode(node.args[1]!, context);\n    if (ignoreEmptyResult.type === \"error\") {\n      return ignoreEmptyResult;\n    }\n    if (ignoreEmptyResult.type === \"awaiting-evaluation\") {\n      return ignoreEmptyResult;\n    }\n\n    // ignore_empty must be a single value\n    if (ignoreEmptyResult.type === \"spilled-values\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN ignore_empty must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Convert ignore_empty to boolean\n    let ignoreEmpty = false;\n    if (ignoreEmptyResult.result.type === \"boolean\") {\n      ignoreEmpty = ignoreEmptyResult.result.value;\n    } else if (ignoreEmptyResult.result.type === \"number\") {\n      ignoreEmpty = ignoreEmptyResult.result.value !== 0;\n    } else if (ignoreEmptyResult.result.type === \"string\") {\n      ignoreEmpty = ignoreEmptyResult.result.value !== \"\";\n    }\n\n    // Evaluate text arguments (remaining arguments)\n    const textArgs: FunctionEvaluationResult[] = [];\n    for (let i = 2; i < node.args.length; i++) {\n      const result = this.evaluateNode(node.args[i]!, context);\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      textArgs.push(result);\n    }\n\n    // Collect all text items from arguments\n    const textItems = collectTextItems.call(\n      this,\n      textArgs,\n      ignoreEmpty,\n      context\n    );\n\n    // Check if we got an error\n    if (!Array.isArray(textItems)) {\n      return textItems;\n    }\n\n    // Join text items with delimiter\n    const result = textItems.join(delimiter);\n\n    // Check length limit\n    if (result.length > MAX_TEXT_LENGTH) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `TEXTJOIN result exceeds ${MAX_TEXT_LENGTH} character limit`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    return {\n      type: \"value\",\n      result: { type: \"string\", value: result },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaO,IAbP;AAoCA,IAAM,kBAAkB;AAKxB,SAAS,cAAc,CAAC,OAA0B;AAAA,EAChD,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,MAAM;AAAA,SACV;AAAA,MAEH,IAAI,MAAM,UAAU,UAAU;AAAA,QAC5B,OAAO;AAAA,MACT,EAAO,SAAI,MAAM,UAAU,WAAW;AAAA,QACpC,OAAO;AAAA,MACT,EAAO,SAAI,MAAM,MAAM,KAAK,GAAG;AAAA,QAC7B,OAAO;AAAA,MACT,EAAO;AAAA,QACL,OAAO,MAAM,MAAM,SAAS;AAAA;AAAA,SAE3B;AAAA,MAEH,OAAO,MAAM,QAAQ,SAAS;AAAA,SAC3B;AAAA,MACH,OAAO,MAAM,SAAS,aAAa,aAAa;AAAA;AAAA,MAEhD,OAAO;AAAA;AAAA;AAOb,SAAS,gBAAgB,CAEvB,MACA,aACA,SACkC;AAAA,EAClC,MAAM,YAAsB,CAAC;AAAA,EAE7B,WAAW,OAAO,MAAM;AAAA,IACtB,IAAI,IAAI,SAAS,SAAS;AAAA,MACxB,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,IAAI,SAAS,SAAS;AAAA,MACxB,MAAM,OAAO,eAAe,IAAI,MAAM;AAAA,MACtC,IAAI,CAAC,eAAe,SAAS,IAAI;AAAA,QAC/B,UAAU,KAAK,IAAI;AAAA,MACrB;AAAA,IACF,EAAO,SAAI,IAAI,SAAS,kBAAkB;AAAA,MAExC,MAAM,aAAa,IAAI,iBAAiB,KAAK,MAAM;AAAA,QACjD;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,UAAU,IAAI;AAAA,QACd,aAAa;AAAA,MACf,CAAC;AAAA,MAED,IAAI,WAAW,SAAS,UAAU;AAAA,QAChC,OAAO;AAAA,MACT;AAAA,MAEA,WAAW,aAAa,WAAW,QAAQ;AAAA,QACzC,IACE,UAAU,OAAO,SAAS,WAC1B,UAAU,OAAO,SAAS,uBAC1B;AAAA,UACA,OAAO,UAAU;AAAA,QACnB;AAAA,QACA,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,UACrC,MAAM,OAAO,eAAe,UAAU,OAAO,MAAM;AAAA,UACnD,IAAI,CAAC,eAAe,SAAS,IAAI;AAAA,YAC/B,UAAU,KAAK,IAAI;AAAA,UACrB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAMF,IAAM,WAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,SAAS,GAAG;AAAA,MACxB,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,kBAAkB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAChE,IAAI,gBAAgB,SAAS,SAAS;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IACA,IAAI,gBAAgB,SAAS,uBAAuB;AAAA,MAClD,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,gBAAgB,SAAS,kBAAkB;AAAA,MAC7C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,YAAY,eAAe,gBAAgB,MAAM;AAAA,IAGvD,MAAM,oBAAoB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAClE,IAAI,kBAAkB,SAAS,SAAS;AAAA,MACtC,OAAO;AAAA,IACT;AAAA,IACA,IAAI,kBAAkB,SAAS,uBAAuB;AAAA,MACpD,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,kBAAkB,SAAS,kBAAkB;AAAA,MAC/C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI,cAAc;AAAA,IAClB,IAAI,kBAAkB,OAAO,SAAS,WAAW;AAAA,MAC/C,cAAc,kBAAkB,OAAO;AAAA,IACzC,EAAO,SAAI,kBAAkB,OAAO,SAAS,UAAU;AAAA,MACrD,cAAc,kBAAkB,OAAO,UAAU;AAAA,IACnD,EAAO,SAAI,kBAAkB,OAAO,SAAS,UAAU;AAAA,MACrD,cAAc,kBAAkB,OAAO,UAAU;AAAA,IACnD;AAAA,IAGA,MAAM,WAAuC,CAAC;AAAA,IAC9C,SAAS,IAAI,EAAG,IAAI,KAAK,KAAK,QAAQ,KAAK;AAAA,MACzC,MAAM,UAAS,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MACvD,IAAI,QAAO,SAAS,WAAW,QAAO,SAAS,uBAAuB;AAAA,QACpE,OAAO;AAAA,MACT;AAAA,MACA,SAAS,KAAK,OAAM;AAAA,IACtB;AAAA,IAGA,MAAM,YAAY,iBAAiB,KACjC,MACA,UACA,aACA,OACF;AAAA,IAGA,IAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAAA,MAC7B,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,SAAS,UAAU,KAAK,SAAS;AAAA,IAGvC,IAAI,OAAO,SAAS,iBAAiB;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,2BAA2B;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,IAC1C;AAAA;AAEJ;",
+  "debugId": "A87D4DCDE3D2304764756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/formula-engine",
+  "version": "0.0.1",
+  "type": "commonjs"
+}

package/dist/cjs/parser/ast.cjs

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/parser/ast.ts
+var exports_ast = {};
+__export(exports_ast, {
+  createValueNode: () => createValueNode,
+  createUnaryOpNode: () => createUnaryOpNode,
+  createThreeDRangeNode: () => createThreeDRangeNode,
+  createStructuredReferenceNode: () => createStructuredReferenceNode,
+  createReferenceNode: () => createReferenceNode,
+  createRangeNode: () => createRangeNode,
+  createNamedExpressionNode: () => createNamedExpressionNode,
+  createInfinityNode: () => createInfinityNode,
+  createFunctionNode: () => createFunctionNode,
+  createErrorNode: () => createErrorNode,
+  createEmptyNode: () => createEmptyNode,
+  createBinaryOpNode: () => createBinaryOpNode,
+  createArrayNode: () => createArrayNode
+});
+module.exports = __toCommonJS(exports_ast);
+function createValueNode(value, position) {
+  return {
+    type: "value",
+    value,
+    position
+  };
+}
+function createEmptyNode(position) {
+  return { type: "empty", position };
+}
+function createReferenceNode({
+  address,
+  isAbsolute,
+  position,
+  sheetName,
+  workbookName
+}) {
+  return {
+    type: "reference",
+    address,
+    isAbsolute,
+    sheetName,
+    workbookName,
+    position
+  };
+}
+function createRangeNode({
+  sheetName,
+  workbookName,
+  range,
+  isAbsolute,
+  position
+}) {
+  return {
+    type: "range",
+    range,
+    sheetName,
+    workbookName,
+    isAbsolute,
+    position
+  };
+}
+function createFunctionNode(name, args, position) {
+  return {
+    type: "function",
+    name: name.toUpperCase(),
+    args,
+    position
+  };
+}
+function createUnaryOpNode(operator, operand, position) {
+  return {
+    type: "unary-op",
+    operator,
+    operand,
+    position
+  };
+}
+function createBinaryOpNode(operator, left, right, position) {
+  return {
+    type: "binary-op",
+    operator,
+    left,
+    right,
+    position
+  };
+}
+function createArrayNode(elements, position) {
+  return {
+    type: "array",
+    elements,
+    position
+  };
+}
+function createNamedExpressionNode(name, position, sheetName, workbookName) {
+  return {
+    type: "named-expression",
+    name,
+    sheetName,
+    workbookName,
+    position
+  };
+}
+function createErrorNode(error, message, position) {
+  return {
+    type: "error",
+    error,
+    message,
+    position
+  };
+}
+function createThreeDRangeNode(startSheet, endSheet, reference, position, workbookName) {
+  return {
+    type: "3d-range",
+    startSheet,
+    endSheet,
+    workbookName,
+    reference,
+    position
+  };
+}
+function createStructuredReferenceNode({
+  tableName,
+  sheetName,
+  workbookName,
+  cols,
+  selector,
+  isCurrentRow = false,
+  position
+}) {
+  return {
+    type: "structured-reference",
+    tableName,
+    sheetName,
+    workbookName,
+    cols,
+    selector,
+    isCurrentRow,
+    position
+  };
+}
+function createInfinityNode(position) {
+  return {
+    type: "infinity",
+    position
+  };
+}
+
+//# debugId=01361EAD00AC639464756E2164756E21

package/dist/cjs/parser/ast.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/parser/ast.ts"],
+  "sourcesContent": [
+    "/**\n * Abstract Syntax Tree (AST) node definitions for formula parsing\n */\n\nimport type {\n  CellAddress,\n  CellValue,\n  FormulaError,\n  SpreadsheetRange,\n} from \"../core/types.cjs\";\n\n/**\n * Base interface for all AST nodes\n */\ntype ASTNodeBase = {\n  position?: {\n    start: number;\n    end: number;\n  };\n};\n\n/**\n * Literal value node (number, string, boolean, error)\n */\nexport type ValueNode = ASTNodeBase & {\n  type: \"value\";\n  value: CellValue;\n};\n\n/**\n * Cell reference node (e.g., A1, Sheet1!B2)\n */\nexport type ReferenceNode = ASTNodeBase & {\n  type: \"reference\";\n  address: {\n    colIndex: number;\n    rowIndex: number;\n  };\n  sheetName?: string;\n  workbookName?: string;\n  isAbsolute: {\n    col: boolean;\n    row: boolean;\n  };\n};\n\n/**\n * Range reference node (e.g., A1:B10)\n */\nexport type RangeNode = ASTNodeBase & {\n  type: \"range\";\n  sheetName?: string;\n  workbookName?: string;\n  range: SpreadsheetRange;\n  isAbsolute: {\n    start: {\n      col: boolean;\n      row: boolean;\n    };\n    end: {\n      col: boolean;\n      row: boolean;\n    };\n  };\n};\n\n/**\n * Function call node (e.g., SUM(A1:A10))\n */\nexport type FunctionNode = ASTNodeBase & {\n  type: \"function\";\n  name: string;\n  args: ASTNode[];\n};\n\n/**\n * Unary operator node (e.g., -A1, +B2)\n */\nexport type UnaryOpNode = ASTNodeBase & {\n  type: \"unary-op\";\n  operator: \"+\" | \"-\" | \"%\";\n  operand: ASTNode;\n};\n\n/**\n * Binary operator node (e.g., A1+B1, C1*D1)\n */\nexport type BinaryOpNode = ASTNodeBase & {\n  type: \"binary-op\";\n  operator:\n    | \"+\"\n    | \"-\"\n    | \"*\"\n    | \"/\"\n    | \"^\"\n    | \"&\"\n    | \"=\"\n    | \"<>\"\n    | \"<\"\n    | \">\"\n    | \"<=\"\n    | \">=\";\n  left: ASTNode;\n  right: ASTNode;\n};\n\n/**\n * Array literal node (e.g., {1,2,3;4,5,6})\n */\nexport type ArrayNode = ASTNodeBase & {\n  type: \"array\";\n  elements: ASTNode[][]; // 2D array of elements\n};\n\n/**\n * 3D range node (e.g., Sheet1:Sheet3!A1)\n */\nexport type ThreeDRangeNode = ASTNodeBase & {\n  type: \"3d-range\";\n  startSheet: string;\n  endSheet: string;\n  workbookName?: string;\n  reference: ReferenceNode | RangeNode;\n};\n\n/**\n * Structured reference node (e.g., Table1[Column1])\n */\nexport type StructuredReferenceNode = ASTNodeBase & {\n  type: \"structured-reference\";\n  tableName?: string;\n  sheetName?: string;\n  workbookName?: string;\n  cols?: {\n    startCol: string;\n    endCol: string;\n  };\n  selector?: \"#All\" | \"#Data\" | \"#Headers\";\n  isCurrentRow: boolean;\n};\n\n/**\n * Infinity literal node\n */\nexport type InfinityNode = ASTNodeBase & {\n  type: \"infinity\";\n};\n\nexport type ASTNode =\n  | ValueNode\n  | ReferenceNode\n  | RangeNode\n  | FunctionNode\n  | UnaryOpNode\n  | BinaryOpNode\n  | ArrayNode\n  | NamedExpressionNode\n  | ErrorNode\n  | EmptyNode\n  | ThreeDRangeNode\n  | StructuredReferenceNode\n  | InfinityNode;\n\n/**\n * Named expression reference node\n */\nexport type NamedExpressionNode = ASTNodeBase & {\n  type: \"named-expression\";\n  name: string;\n  sheetName?: string;\n  workbookName?: string;\n};\n\n/**\n * Error node for parsing errors\n */\nexport type ErrorNode = ASTNodeBase & {\n  type: \"error\";\n  error: FormulaError;\n  message: string;\n};\n\nexport type EmptyNode = ASTNodeBase & {\n  type: \"empty\";\n};\n\n/**\n * Helper function to create a value node\n */\nexport function createValueNode(\n  value: CellValue,\n  position?: {\n    start: number;\n    end: number;\n  }\n): ValueNode {\n  return {\n    type: \"value\",\n    value,\n    position,\n  };\n}\n\nexport function createEmptyNode(position?: {\n  start: number;\n  end: number;\n}): EmptyNode {\n  return { type: \"empty\", position };\n}\n\n/**\n * Helper function to create a reference node\n */\nexport function createReferenceNode({\n  address,\n  isAbsolute,\n  position,\n  sheetName,\n  workbookName,\n}: {\n  address: {\n    colIndex: number;\n    rowIndex: number;\n  };\n  isAbsolute: { col: boolean; row: boolean };\n  position?: {\n    start: number;\n    end: number;\n  };\n  sheetName?: string;\n  workbookName?: string;\n}): ReferenceNode {\n  return {\n    type: \"reference\",\n    address,\n    isAbsolute,\n    sheetName,\n    workbookName,\n    position,\n  };\n}\n\n/**\n * Helper function to create a range node\n */\nexport function createRangeNode({\n  sheetName,\n  workbookName,\n  range,\n  isAbsolute,\n  position,\n}: {\n  sheetName?: string;\n  workbookName?: string;\n  range: SpreadsheetRange;\n  isAbsolute: RangeNode[\"isAbsolute\"];\n  position?: {\n    start: number;\n    end: number;\n  };\n}): RangeNode {\n  return {\n    type: \"range\",\n    range,\n    sheetName,\n    workbookName,\n    isAbsolute,\n    position,\n  };\n}\n\n/**\n * Helper function to create a function node\n */\nexport function createFunctionNode(\n  name: string,\n  args: ASTNode[],\n  position?: {\n    start: number;\n    end: number;\n  }\n): FunctionNode {\n  return {\n    type: \"function\",\n    name: name.toUpperCase(), // Normalize function names to uppercase\n    args,\n    position,\n  };\n}\n\n/**\n * Helper function to create a unary operator node\n */\nexport function createUnaryOpNode(\n  operator: UnaryOpNode[\"operator\"],\n  operand: ASTNode,\n  position?: {\n    start: number;\n    end: number;\n  }\n): UnaryOpNode {\n  return {\n    type: \"unary-op\",\n    operator,\n    operand,\n    position,\n  };\n}\n\n/**\n * Helper function to create a binary operator node\n */\nexport function createBinaryOpNode(\n  operator: BinaryOpNode[\"operator\"],\n  left: ASTNode,\n  right: ASTNode,\n  position?: {\n    start: number;\n    end: number;\n  }\n): BinaryOpNode {\n  return {\n    type: \"binary-op\",\n    operator,\n    left,\n    right,\n    position,\n  };\n}\n\n/**\n * Helper function to create an array node\n */\nexport function createArrayNode(\n  elements: ASTNode[][],\n  position?: {\n    start: number;\n    end: number;\n  }\n): ArrayNode {\n  return {\n    type: \"array\",\n    elements,\n    position,\n  };\n}\n\n/**\n * Helper function to create a named expression node\n */\nexport function createNamedExpressionNode(\n  name: string,\n  position?: {\n    start: number;\n    end: number;\n  },\n  sheetName?: string,\n  workbookName?: string\n): NamedExpressionNode {\n  return {\n    type: \"named-expression\",\n    name,\n    sheetName,\n    workbookName,\n    position,\n  };\n}\n\n/**\n * Helper function to create an error node\n */\nexport function createErrorNode(\n  error: FormulaError,\n  message: string,\n  position?: {\n    start: number;\n    end: number;\n  }\n): ErrorNode {\n  return {\n    type: \"error\",\n    error,\n    message,\n    position,\n  };\n}\n\n/**\n * Helper function to create a 3D range node\n */\nexport function createThreeDRangeNode(\n  startSheet: string,\n  endSheet: string,\n  reference: ReferenceNode | RangeNode,\n  position?: {\n    start: number;\n    end: number;\n  },\n  workbookName?: string\n): ThreeDRangeNode {\n  return {\n    type: \"3d-range\",\n    startSheet,\n    endSheet,\n    workbookName,\n    reference,\n    position,\n  };\n}\n\n/**\n * Helper function to create a structured reference node\n */\nexport function createStructuredReferenceNode({\n  tableName,\n  sheetName,\n  workbookName,\n  cols,\n  selector,\n  isCurrentRow = false,\n  position,\n}: {\n  tableName?: string;\n  sheetName?: string;\n  workbookName?: string;\n  cols?: {\n    startCol: string;\n    endCol: string;\n  };\n  selector?: \"#All\" | \"#Data\" | \"#Headers\";\n  isCurrentRow?: boolean;\n  position?: {\n    start: number;\n    end: number;\n  };\n}): StructuredReferenceNode {\n  return {\n    type: \"structured-reference\",\n    tableName,\n    sheetName,\n    workbookName,\n    cols,\n    selector,\n    isCurrentRow,\n    position,\n  };\n}\n\n/**\n * Helper function to create an infinity node\n */\nexport function createInfinityNode(position?: {\n  start: number;\n  end: number;\n}): InfinityNode {\n  return {\n    type: \"infinity\",\n    position,\n  };\n}\n\n/**\n * AST visitor interface for traversing the tree\n */\nexport interface ASTVisitor<T = void> {\n  visitValue?(node: ValueNode): T;\n  visitReference?(node: ReferenceNode): T;\n  visitRange?(node: RangeNode): T;\n  visitFunction?(node: FunctionNode): T;\n  visitUnaryOp?(node: UnaryOpNode): T;\n  visitBinaryOp?(node: BinaryOpNode): T;\n  visitArray?(node: ArrayNode): T;\n  visitNamedExpression?(node: NamedExpressionNode): T;\n  visitError?(node: ErrorNode): T;\n  visitEmpty?(node: EmptyNode): T;\n  visitThreeDRange?(node: ThreeDRangeNode): T;\n  visitStructuredReference?(node: StructuredReferenceNode): T;\n  visitInfinity?(node: InfinityNode): T;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6LO,SAAS,eAAe,CAC7B,OACA,UAIW;AAAA,EACX,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EACF;AAAA;AAGK,SAAS,eAAe,CAAC,UAGlB;AAAA,EACZ,OAAO,EAAE,MAAM,SAAS,SAAS;AAAA;AAM5B,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,GAagB;AAAA,EAChB,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,eAAe;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,GAUY;AAAA,EACZ,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,kBAAkB,CAChC,MACA,MACA,UAIc;AAAA,EACd,OAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK,YAAY;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,iBAAiB,CAC/B,UACA,SACA,UAIa;AAAA,EACb,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,kBAAkB,CAChC,UACA,MACA,OACA,UAIc;AAAA,EACd,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,eAAe,CAC7B,UACA,UAIW;AAAA,EACX,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,yBAAyB,CACvC,MACA,UAIA,WACA,cACqB;AAAA,EACrB,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,eAAe,CAC7B,OACA,SACA,UAIW;AAAA,EACX,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,qBAAqB,CACnC,YACA,UACA,WACA,UAIA,cACiB;AAAA,EACjB,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,6BAA6B;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,eAAe;AAAA,EACf;AAAA,GAe0B;AAAA,EAC1B,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAMK,SAAS,kBAAkB,CAAC,UAGlB;AAAA,EACf,OAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,EACF;AAAA;",
+  "debugId": "01361EAD00AC639464756E2164756E21",
+  "names": []
+}