@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/text/len/len.cjs

@@ -0,0 +1,119 @@
+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/len/len.ts
+var exports_len = {};
+__export(exports_len, {
+  LEN: () => LEN
+});
+module.exports = __toCommonJS(exports_len);
+var import_types = require("src/core/types");
+var LEN = {
+  name: "LEN",
+  evaluate: function(node, context) {
+    if (node.args.length !== 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "LEN function takes exactly 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error" || textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    if (textResult.type === "spilled-values") {
+      return createLenSpilledResult.call(this, {
+        textResult,
+        context
+      });
+    }
+    if (textResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Text argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (textResult.result.type === "string") {
+      return {
+        type: "value",
+        result: { type: "number", value: textResult.result.value.length }
+      };
+    }
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "LEN operation failed",
+      errAddress: context.dependencyNode
+    };
+  }
+};
+function createLenSpilledResult({
+  textResult,
+  context
+}) {
+  if (textResult.type !== "spilled-values") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "createLenSpilledResult called without spilled values",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => textResult.spillArea(origin),
+    source: "LEN with spilled text values",
+    evaluate: (spillOffset, evalContext) => {
+      const spillTextResult = textResult.evaluate(spillOffset, evalContext);
+      if (!spillTextResult || spillTextResult.type === "error" || spillTextResult.type === "awaiting-evaluation") {
+        return spillTextResult;
+      }
+      if (spillTextResult.type !== "value" || spillTextResult.result.type !== "string") {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "LEN operation failed",
+          errAddress: context.dependencyNode
+        };
+      }
+      return {
+        type: "value",
+        result: { type: "number", value: spillTextResult.result.value.length }
+      };
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for LEN is not implemented");
+    }
+  };
+}
+
+//# debugId=C318A6303594CA3464756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/len/len.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type CellNumber,\n  type CellAddress,\n  type SpreadsheetRange,\n} from \"src/core/types\";\nimport { convertToString } from \"../text-helpers.cjs\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * LEN function - Returns the length of a text string\n *\n * Usage: LEN(text)\n *\n * text: The text string whose length you want to find.\n *\n * Example: LEN(\"Hello World\") returns 11\n *\n * Note:\n * - Supports dynamic arrays (spilled values) for the text argument\n * - Strict type checking: text must be string\n * - Returns the number of characters in the text string\n */\nexport const LEN: FunctionDefinition = {\n  name: \"LEN\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"LEN function takes exactly 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the text argument\n    const textResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      textResult.type === \"error\" ||\n      textResult.type === \"awaiting-evaluation\"\n    ) {\n      return textResult;\n    }\n\n    // Handle spilled-values input\n    if (textResult.type === \"spilled-values\") {\n      return createLenSpilledResult.call(this, {\n        textResult,\n        context,\n      });\n    }\n\n    // Strict type checking - no coercion\n    if (textResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Text argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (textResult.result.type === \"string\") {\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: textResult.result.value.length },\n      };\n    }\n\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"LEN operation failed\",\n      errAddress: context.dependencyNode,\n    };\n  },\n};\n\n/**\n * Helper for creating spilled-values result for LEN function\n */\nfunction createLenSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResult,\n    context,\n  }: {\n    textResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): FunctionEvaluationResult {\n  if (textResult.type !== \"spilled-values\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"createLenSpilledResult called without spilled values\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress) => textResult.spillArea(origin),\n    source: \"LEN with spilled text values\",\n    evaluate: (spillOffset, evalContext) => {\n      const spillTextResult = textResult.evaluate(spillOffset, evalContext);\n      if (\n        !spillTextResult ||\n        spillTextResult.type === \"error\" ||\n        spillTextResult.type === \"awaiting-evaluation\"\n      ) {\n        return spillTextResult;\n      }\n\n      if (\n        spillTextResult.type !== \"value\" ||\n        spillTextResult.result.type !== \"string\"\n      ) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"LEN operation failed\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: spillTextResult.result.value.length },\n      };\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\"WIP: evaluateAllCells for LEN is not implemented\");\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAPP;AA0BO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,aAAa,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC3D,IACE,WAAW,SAAS,WACpB,WAAW,SAAS,uBACpB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,WAAW,SAAS,kBAAkB;AAAA,MACxC,OAAO,uBAAuB,KAAK,MAAM;AAAA,QACvC;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAGA,IAAI,WAAW,OAAO,SAAS,UAAU;AAAA,MACvC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,IAAI,WAAW,OAAO,SAAS,UAAU;AAAA,MACvC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ,EAAE,MAAM,UAAU,OAAO,WAAW,OAAO,MAAM,OAAO;AAAA,MAClE;AAAA,IACF;AAAA,IAEA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS;AAAA,MACT,YAAY,QAAQ;AAAA,IACtB;AAAA;AAEJ;AAKA,SAAS,sBAAsB;AAAA,EAG3B;AAAA,EACA;AAAA,GAKwB;AAAA,EAC1B,IAAI,WAAW,SAAS,kBAAkB;AAAA,IACxC,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS;AAAA,MACT,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,WAAW,CAAC,WAAwB,WAAW,UAAU,MAAM;AAAA,IAC/D,QAAQ;AAAA,IACR,UAAU,CAAC,aAAa,gBAAgB;AAAA,MACtC,MAAM,kBAAkB,WAAW,SAAS,aAAa,WAAW;AAAA,MACpE,IACE,CAAC,mBACD,gBAAgB,SAAS,WACzB,gBAAgB,SAAS,uBACzB;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MAEA,IACE,gBAAgB,SAAS,WACzB,gBAAgB,OAAO,SAAS,UAChC;AAAA,QACA,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ,EAAE,MAAM,UAAU,OAAO,gBAAgB,OAAO,MAAM,OAAO;AAAA,MACvE;AAAA;AAAA,IAEF,kBAAkB,CAAC,sBAAsB;AAAA,MACvC,MAAM,IAAI,MAAM,kDAAkD;AAAA;AAAA,EAEtE;AAAA;",
+  "debugId": "C318A6303594CA3464756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/mid/mid.cjs

@@ -0,0 +1,103 @@
+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/mid/mid.ts
+var exports_mid = {};
+__export(exports_mid, {
+  MID: () => MID
+});
+module.exports = __toCommonJS(exports_mid);
+var import_types = require("src/core/types");
+var import_text_helpers = require("../text-helpers.cjs");
+var MID = {
+  name: "MID",
+  evaluate: function(node, context) {
+    if (node.args.length !== 3) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "MID function takes exactly 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error" || textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    const startNumResult = this.evaluateNode(node.args[1], context);
+    if (startNumResult.type === "error" || startNumResult.type === "awaiting-evaluation") {
+      return startNumResult;
+    }
+    const numCharsResult = this.evaluateNode(node.args[2], context);
+    if (numCharsResult.type === "error" || numCharsResult.type === "awaiting-evaluation") {
+      return numCharsResult;
+    }
+    if (textResult.type === "spilled-values" || startNumResult.type === "spilled-values" || numCharsResult.type === "spilled-values") {
+      return import_text_helpers.createMidSpilledResult.call(this, {
+        textResult,
+        startNumResult,
+        numCharsResult,
+        context
+      });
+    }
+    if (textResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Text argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (startNumResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Start_num argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numCharsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Num_chars argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = import_text_helpers.midOperation(textResult, startNumResult, numCharsResult, context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    return {
+      type: "value",
+      result: result.result
+    };
+  }
+};
+
+//# debugId=4A2485640856964964756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/mid/mid.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport { midOperation, createMidSpilledResult } from \"../text-helpers.cjs\";\n\n/**\n * MID function - Returns characters from the middle of a text string\n *\n * Usage: MID(text, start_num, num_chars)\n *\n * text: The text string to extract characters from.\n * start_num: The position of the first character to extract (1-based).\n * num_chars: The number of characters to extract.\n *\n * Example: MID(\"Hello, World!\", 8, 5) returns \"World\"\n *\n * Note:\n * - If start_num is less than 1, the function returns an error.\n * - If num_chars is less than 0, the function returns an error.\n * - If start_num is greater than the length of text, the function returns an empty string.\n * - Supports dynamic arrays (spilled values) for all arguments\n * - Strict type checking: text must be string, start_num and num_chars must be numbers\n */\nexport const MID: FunctionDefinition = {\n  name: \"MID\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"MID function takes exactly 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the text argument\n    const textResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      textResult.type === \"error\" ||\n      textResult.type === \"awaiting-evaluation\"\n    ) {\n      return textResult;\n    }\n\n    // Evaluate the start_num argument\n    const startNumResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      startNumResult.type === \"error\" ||\n      startNumResult.type === \"awaiting-evaluation\"\n    ) {\n      return startNumResult;\n    }\n\n    // Evaluate the num_chars argument\n    const numCharsResult = this.evaluateNode(node.args[2]!, context);\n    if (\n      numCharsResult.type === \"error\" ||\n      numCharsResult.type === \"awaiting-evaluation\"\n    ) {\n      return numCharsResult;\n    }\n\n    // Handle spilled-values inputs\n    if (\n      textResult.type === \"spilled-values\" ||\n      startNumResult.type === \"spilled-values\" ||\n      numCharsResult.type === \"spilled-values\"\n    ) {\n      return createMidSpilledResult.call(this, {\n        textResult,\n        startNumResult,\n        numCharsResult,\n        context,\n      });\n    }\n\n    // Strict type checking - no coercion\n    if (textResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Text argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (startNumResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Start_num argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (numCharsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Num_chars argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const result = midOperation(\n      textResult,\n      startNumResult,\n      numCharsResult,\n      context\n    );\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n    return {\n      type: \"value\",\n      result: result.result,\n    };\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AAKqD,IAArD;AAoBO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,aAAa,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC3D,IACE,WAAW,SAAS,WACpB,WAAW,SAAS,uBACpB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IACE,eAAe,SAAS,WACxB,eAAe,SAAS,uBACxB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IACE,eAAe,SAAS,WACxB,eAAe,SAAS,uBACxB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,IACE,WAAW,SAAS,oBACpB,eAAe,SAAS,oBACxB,eAAe,SAAS,kBACxB;AAAA,MACA,OAAO,2CAAuB,KAAK,MAAM;AAAA,QACvC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAGA,IAAI,WAAW,OAAO,SAAS,UAAU;AAAA,MACvC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,IAAI,eAAe,OAAO,SAAS,UAAU;AAAA,MAC3C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,IAAI,eAAe,OAAO,SAAS,UAAU;AAAA,MAC3C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,SAAS,iCACb,YACA,gBACA,gBACA,OACF;AAAA,IACA,IAAI,OAAO,SAAS,WAAW,OAAO,SAAS,uBAAuB;AAAA,MACpE,OAAO;AAAA,IACT;AAAA,IACA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,OAAO;AAAA,IACjB;AAAA;AAEJ;",
+  "debugId": "4A2485640856964964756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/right/right.cjs

@@ -0,0 +1,167 @@
+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/right/right.ts
+var exports_right = {};
+__export(exports_right, {
+  RIGHT: () => RIGHT
+});
+module.exports = __toCommonJS(exports_right);
+var import_types = require("src/core/types");
+var import_text_helpers = require("../text-helpers.cjs");
+function rightOperation(textResult, numCharsResult, context) {
+  const textStr = import_text_helpers.convertToString(textResult, context);
+  const numChars = import_text_helpers.extractNumericValue(numCharsResult, context);
+  if (typeof textStr === "object" && (textStr.type === "awaiting-evaluation" || textStr.type === "error")) {
+    return textStr;
+  }
+  if (typeof numChars === "object" && (numChars.type === "awaiting-evaluation" || numChars.type === "error")) {
+    return numChars;
+  }
+  const textValue = textStr;
+  const numCharsValue = numChars;
+  if (numCharsValue < 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "NumChars argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  const textLength = textValue.length;
+  const startPos = Math.max(1, textLength - Math.floor(numCharsValue) + 1);
+  const startNumResult = {
+    type: "value",
+    result: { type: "number", value: startPos }
+  };
+  return import_text_helpers.midOperation(textResult, startNumResult, numCharsResult, context);
+}
+var RIGHT = {
+  name: "RIGHT",
+  evaluate: function(node, context) {
+    if (node.args.length < 1 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "RIGHT function takes 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error" || textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    let numCharsResult;
+    if (node.args.length > 1) {
+      numCharsResult = this.evaluateNode(node.args[1], context);
+      if (numCharsResult.type === "error" || numCharsResult.type === "awaiting-evaluation") {
+        return numCharsResult;
+      }
+    } else {
+      numCharsResult = {
+        type: "value",
+        result: { type: "number", value: 1 }
+      };
+    }
+    if (textResult.type === "spilled-values" || numCharsResult.type === "spilled-values") {
+      return createRightSpilledResult.call(this, {
+        textResult,
+        numCharsResult,
+        context
+      });
+    }
+    if (textResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Text argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numCharsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "NumChars argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    return rightOperation(textResult, numCharsResult, context);
+  }
+};
+function createRightSpilledResult({
+  textResult,
+  numCharsResult,
+  context
+}) {
+  if (textResult.type !== "spilled-values" && numCharsResult.type !== "spilled-values") {
+    throw new Error("createRightSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      if (textResult.type === "spilled-values") {
+        spillArea = textResult.spillArea(origin);
+      } else if (numCharsResult.type === "spilled-values") {
+        spillArea = numCharsResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+      if (textResult.type === "spilled-values" && numCharsResult.type === "spilled-values") {
+        spillArea = this.unionRanges(this.projectRange(textResult.spillArea(origin), origin), this.projectRange(numCharsResult.spillArea(origin), origin));
+      }
+      return spillArea;
+    },
+    source: "RIGHT with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillTextResult = textResult.type === "spilled-values" ? textResult.evaluate(spilledCell, evalContext) : textResult;
+      const spillNumResult = numCharsResult.type === "spilled-values" ? numCharsResult.evaluate(spilledCell, evalContext) : numCharsResult;
+      if (spillTextResult === undefined || spillNumResult === undefined) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: "The spilled results have not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillNumResult.type === "error") {
+        return spillNumResult;
+      }
+      if (spillTextResult.type === "error") {
+        return spillTextResult;
+      }
+      return rightOperation(spillTextResult, spillNumResult, context);
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for RIGHT is not implemented");
+    }
+  };
+}
+
+//# debugId=677703F9538EF34864756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/right/right.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type CellString,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport {\n  midOperation,\n  createMidSpilledResult,\n  convertToString,\n  extractNumericValue,\n} from \"../text-helpers.cjs\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * RIGHT function - Returns the rightmost characters from a text string\n *\n * Usage: RIGHT(text, num_chars)\n *\n * text: The text string to extract characters from.\n * num_chars: The number of characters to extract from the right side of the text.\n *\n * Example: RIGHT(\"Hello, World!\", 6) returns \"World!\"\n *\n * Note:\n * - If num_chars is less than 0, the function returns an error.\n * - If num_chars is greater than the length of text, the function returns the entire text.\n * - Supports dynamic arrays (spilled values) for both arguments\n * - Strict type checking: text must be string, num_chars must be number\n * - Implemented as MID(text, LEN(text) - num_chars + 1, num_chars)\n */\n\n/**\n * Helper function to calculate RIGHT operation using MID\n */\nfunction rightOperation(\n  textResult: FunctionEvaluationResult,\n  numCharsResult: FunctionEvaluationResult,\n  context: EvaluationContext\n): { type: \"value\"; result: CellString } | ErrorEvaluationResult {\n  const textStr = convertToString(textResult, context);\n  const numChars = extractNumericValue(numCharsResult, context);\n\n  // Check if any of the results are awaiting evaluation or errors\n  if (\n    typeof textStr === \"object\" &&\n    (textStr.type === \"awaiting-evaluation\" || textStr.type === \"error\")\n  ) {\n    return textStr;\n  }\n  if (\n    typeof numChars === \"object\" &&\n    (numChars.type === \"awaiting-evaluation\" || numChars.type === \"error\")\n  ) {\n    return numChars;\n  }\n\n  // At this point, all values should be primitive types\n  const textValue = textStr as string;\n  const numCharsValue = numChars as number;\n\n  // Validate numChars\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  // Calculate start position: LEN(text) - num_chars + 1\n  const textLength = textValue.length;\n  const startPos = Math.max(1, textLength - Math.floor(numCharsValue) + 1);\n\n  // Create start_num result\n  const startNumResult: FunctionEvaluationResult = {\n    type: \"value\",\n    result: { type: \"number\", value: startPos },\n  };\n\n  // Use MID operation\n  return midOperation(textResult, startNumResult, numCharsResult, context);\n}\n\nexport const RIGHT: FunctionDefinition = {\n  name: \"RIGHT\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 1 || node.args.length > 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"RIGHT function takes 1 or 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the text argument\n    const textResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      textResult.type === \"error\" ||\n      textResult.type === \"awaiting-evaluation\"\n    ) {\n      return textResult;\n    }\n\n    // Evaluate the numChars argument (optional, defaults to 1)\n    let numCharsResult: FunctionEvaluationResult;\n    if (node.args.length > 1) {\n      numCharsResult = this.evaluateNode(node.args[1]!, context);\n      if (\n        numCharsResult.type === \"error\" ||\n        numCharsResult.type === \"awaiting-evaluation\"\n      ) {\n        return numCharsResult;\n      }\n    } else {\n      numCharsResult = {\n        type: \"value\",\n        result: { type: \"number\", value: 1 },\n      };\n    }\n\n    // Handle spilled-values inputs\n    if (\n      textResult.type === \"spilled-values\" ||\n      numCharsResult.type === \"spilled-values\"\n    ) {\n      // For RIGHT with spilled values, we need a custom spilled result handler\n      // because we need to calculate start_num dynamically for each text value\n      return createRightSpilledResult.call(this, {\n        textResult,\n        numCharsResult,\n        context,\n      });\n    }\n\n    // Strict type checking - no coercion\n    if (textResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Text argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (numCharsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"NumChars argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Use RIGHT operation: RIGHT(text, num_chars) = MID(text, LEN(text) - num_chars + 1, num_chars)\n    return rightOperation(textResult, numCharsResult, context);\n  },\n};\n\n/**\n * Helper for creating spilled-values result for RIGHT function\n */\nfunction createRightSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResult,\n    numCharsResult,\n    context,\n  }: {\n    textResult: FunctionEvaluationResult;\n    numCharsResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  if (\n    textResult.type !== \"spilled-values\" &&\n    numCharsResult.type !== \"spilled-values\"\n  ) {\n    throw new Error(\"createRightSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress): SpreadsheetRange => {\n      // Calculate spill area\n      let spillArea;\n      if (textResult.type === \"spilled-values\") {\n        spillArea = textResult.spillArea(origin);\n      } else if (numCharsResult.type === \"spilled-values\") {\n        spillArea = numCharsResult.spillArea(origin);\n      } else {\n        throw new Error(\"No spilled values found\");\n      }\n\n      // Union spill areas if both are spilled\n      if (\n        textResult.type === \"spilled-values\" &&\n        numCharsResult.type === \"spilled-values\"\n      ) {\n        spillArea = this.unionRanges(\n          this.projectRange(textResult.spillArea(origin), origin),\n          this.projectRange(numCharsResult.spillArea(origin), origin)\n        );\n      }\n      return spillArea;\n    },\n    source: \"RIGHT with spilled values\",\n    evaluate: (spilledCell, evalContext): SingleEvaluationResult => {\n      // Evaluate arguments at this spilled position\n      const spillTextResult =\n        textResult.type === \"spilled-values\"\n          ? textResult.evaluate(spilledCell, evalContext)\n          : textResult;\n      const spillNumResult =\n        numCharsResult.type === \"spilled-values\"\n          ? numCharsResult.evaluate(spilledCell, evalContext)\n          : numCharsResult;\n\n      if (spillTextResult === undefined || spillNumResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled results have not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillNumResult.type === \"error\") {\n        return spillNumResult;\n      }\n      if (spillTextResult.type === \"error\") {\n        return spillTextResult;\n      }\n\n      return rightOperation(spillTextResult, spillNumResult, context);\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\"WIP: evaluateAllCells for RIGHT is not implemented\");\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "677703F9538EF34864756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,179 @@
+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/text-helpers.ts
+var exports_text_helpers = {};
+__export(exports_text_helpers, {
+  midOperation: () => midOperation,
+  extractNumericValue: () => extractNumericValue,
+  createMidSpilledResult: () => createMidSpilledResult,
+  convertToString: () => convertToString
+});
+module.exports = __toCommonJS(exports_text_helpers);
+var import_types = require("src/core/types");
+function convertToString(result, context) {
+  if (result.type === "awaiting-evaluation") {
+    return result;
+  }
+  if (result.type !== "value") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Expected a value result",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (result.result.type === "string") {
+    return result.result.value;
+  } else {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Expected a string value",
+      errAddress: context.dependencyNode
+    };
+  }
+}
+function extractNumericValue(result, context) {
+  if (result.type === "awaiting-evaluation") {
+    return result;
+  }
+  if (result.type !== "value") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Expected a value result",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (result.result.type === "number") {
+    return result.result.value;
+  } else {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Expected a number value",
+      errAddress: context.dependencyNode
+    };
+  }
+}
+function midOperation(textResult, startNumResult, numCharsResult, context) {
+  const textStr = convertToString(textResult, context);
+  const startNum = extractNumericValue(startNumResult, context);
+  const numChars = extractNumericValue(numCharsResult, context);
+  if (typeof textStr === "object" && (textStr.type === "awaiting-evaluation" || textStr.type === "error")) {
+    return textStr;
+  }
+  if (typeof startNum === "object" && (startNum.type === "awaiting-evaluation" || startNum.type === "error")) {
+    return startNum;
+  }
+  if (typeof numChars === "object" && (numChars.type === "awaiting-evaluation" || numChars.type === "error")) {
+    return numChars;
+  }
+  const textValue = textStr;
+  const startNumValue = startNum;
+  const numCharsValue = numChars;
+  if (startNumValue < 1) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "StartNum argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (numCharsValue < 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "NumChars argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  const startIndex = Math.floor(startNumValue) - 1;
+  const length = Math.floor(numCharsValue);
+  const result = textValue.substring(startIndex, startIndex + length);
+  return { type: "value", result: { type: "string", value: result } };
+}
+function createMidSpilledResult({
+  textResult,
+  startNumResult,
+  numCharsResult,
+  context
+}) {
+  const hasSpilledText = textResult.type === "spilled-values";
+  const hasSpilledStart = startNumResult.type === "spilled-values";
+  const hasSpilledNum = numCharsResult.type === "spilled-values";
+  if (!hasSpilledText && !hasSpilledStart && !hasSpilledNum) {
+    throw new Error("createMidSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      if (hasSpilledText && textResult.type === "spilled-values") {
+        spillArea = textResult.spillArea(origin);
+      } else if (hasSpilledStart && startNumResult.type === "spilled-values") {
+        spillArea = startNumResult.spillArea(origin);
+      } else if (hasSpilledNum && numCharsResult.type === "spilled-values") {
+        spillArea = numCharsResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+      if (hasSpilledText && hasSpilledStart && textResult.type === "spilled-values" && startNumResult.type === "spilled-values") {
+        spillArea = this.unionRanges(this.projectRange(textResult.spillArea(origin), origin), this.projectRange(startNumResult.spillArea(origin), origin));
+      }
+      if ((hasSpilledText || hasSpilledStart) && hasSpilledNum && numCharsResult.type === "spilled-values") {
+        const projectedSpillArea = this.projectRange(spillArea, origin);
+        const numSpillArea = this.projectRange(numCharsResult.spillArea(origin), origin);
+        spillArea = this.unionRanges(projectedSpillArea, numSpillArea);
+      }
+      return spillArea;
+    },
+    source: "MID with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillTextResult = hasSpilledText ? textResult.evaluate(spilledCell, evalContext) : textResult;
+      const spillStartResult = hasSpilledStart ? startNumResult.evaluate(spilledCell, evalContext) : startNumResult;
+      const spillNumResult = hasSpilledNum ? numCharsResult.evaluate(spilledCell, evalContext) : numCharsResult;
+      if (!spillTextResult || spillTextResult.type === "error") {
+        return spillTextResult;
+      }
+      if (!spillStartResult || spillStartResult.type === "error") {
+        return spillStartResult;
+      }
+      if (!spillNumResult || spillNumResult.type === "error") {
+        return spillNumResult;
+      }
+      return midOperation(spillTextResult, spillStartResult, spillNumResult, evalContext);
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for MID is not implemented");
+    }
+  };
+}
+
+//# debugId=81F08635A25A4B9364756E2164756E21