@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/text/find/find.cjs

@@ -0,0 +1,397 @@
+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/find/find.ts
+var exports_find = {};
+__export(exports_find, {
+  FIND: () => FIND
+});
+module.exports = __toCommonJS(exports_find);
+var import_types = require("src/core/types");
+var import_text_helpers = require("../text-helpers.cjs");
+function findOperation(findTextResult, withinTextResult, startNumResult, context) {
+  const findStr = import_text_helpers.convertToString(findTextResult, context);
+  const withinStr = import_text_helpers.convertToString(withinTextResult, context);
+  const startNum = import_text_helpers.extractNumericValue(startNumResult, context);
+  if (typeof findStr === "object" && (findStr.type === "awaiting-evaluation" || findStr.type === "error")) {
+    return findStr;
+  }
+  if (typeof withinStr === "object" && (withinStr.type === "awaiting-evaluation" || withinStr.type === "error")) {
+    return withinStr;
+  }
+  if (typeof startNum === "object" && (startNum.type === "awaiting-evaluation" || startNum.type === "error")) {
+    return startNum;
+  }
+  const findValue = findStr;
+  const withinValue = withinStr;
+  const startNumValue = startNum;
+  if (startNumValue < 1) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Text not found #2",
+      errAddress: context.dependencyNode
+    };
+  }
+  const start = Math.floor(startNumValue) - 1;
+  if (start >= withinValue.length) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Text not found #2",
+      errAddress: context.dependencyNode
+    };
+  }
+  const index = withinValue.indexOf(findValue, start);
+  if (index === -1) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Text not found #2",
+      errAddress: context.dependencyNode
+    };
+  }
+  return { type: "number", value: index + 1 };
+}
+function createFindSpilledResult({
+  findTextResult,
+  withinTextResult,
+  startNumResult,
+  context
+}) {
+  if (findTextResult.type === "spilled-values" && withinTextResult.type === "spilled-values") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => {
+        let spillArea = this.unionRanges(this.projectRange(findTextResult.spillArea(origin), origin), this.projectRange(withinTextResult.spillArea(origin), origin));
+        if (startNumResult.type === "spilled-values") {
+          spillArea = this.unionRanges(spillArea, this.projectRange(startNumResult.spillArea(origin), origin));
+        }
+        return spillArea;
+      },
+      source: "FIND with zipped spilled findText and withinText values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillFindResult = findTextResult.evaluate(spillOffset, evalContext);
+        const spillWithinResult = withinTextResult.evaluate(spillOffset, evalContext);
+        if (!spillFindResult || spillFindResult.type === "error") {
+          return spillFindResult;
+        }
+        if (!spillWithinResult || spillWithinResult.type === "error") {
+          return spillWithinResult;
+        }
+        let startNumArg = startNumResult;
+        if (startNumResult.type === "spilled-values") {
+          const spillStartNumResult = startNumResult.evaluate(spillOffset, evalContext);
+          if (!spillStartNumResult || spillStartNumResult.type === "error") {
+            return spillStartNumResult;
+          }
+          startNumArg = spillStartNumResult;
+        }
+        const result = findOperation(spillFindResult, spillWithinResult, startNumArg, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  } else if (findTextResult.type === "spilled-values" && withinTextResult.type !== "spilled-values" && startNumResult.type !== "spilled-values") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => {
+        return findTextResult.spillArea(origin);
+      },
+      source: "FIND with spilled findText values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillResult = findTextResult.evaluate(spillOffset, evalContext);
+        if (!spillResult || spillResult.type === "error") {
+          return spillResult;
+        }
+        const result = findOperation(spillResult, withinTextResult, startNumResult, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  } else if (withinTextResult.type === "spilled-values" && findTextResult.type !== "spilled-values" && startNumResult.type !== "spilled-values") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => withinTextResult.spillArea(origin),
+      source: "FIND with spilled withinText values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillResult = withinTextResult.evaluate(spillOffset, evalContext);
+        if (!spillResult || spillResult.type === "error") {
+          return spillResult;
+        }
+        const result = findOperation(findTextResult, spillResult, startNumResult, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  } else if (findTextResult.type === "spilled-values" && startNumResult.type === "spilled-values" && withinTextResult.type !== "spilled-values") {
+    if (withinTextResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Invalid withinText argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (withinTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "WithinText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => {
+        const spillArea = this.unionRanges(this.projectRange(findTextResult.spillArea(origin), origin), this.projectRange(startNumResult.spillArea(origin), origin));
+        return spillArea;
+      },
+      source: "FIND with spilled findText and startNum values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillFindResult = findTextResult.evaluate(spillOffset, evalContext);
+        const spillStartNumResult = startNumResult.evaluate(spillOffset, evalContext);
+        if (!spillFindResult || spillFindResult.type === "error") {
+          return spillFindResult;
+        }
+        if (!spillStartNumResult || spillStartNumResult.type === "error") {
+          return spillStartNumResult;
+        }
+        const result = findOperation(spillFindResult, withinTextResult, spillStartNumResult, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  } else if (withinTextResult.type === "spilled-values" && startNumResult.type === "spilled-values" && findTextResult.type !== "spilled-values") {
+    if (findTextResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Invalid findText argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (findTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "FindText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => {
+        const spillArea = this.unionRanges(this.projectRange(withinTextResult.spillArea(origin), origin), this.projectRange(startNumResult.spillArea(origin), origin));
+        return spillArea;
+      },
+      source: "FIND with spilled withinText and startNum values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillWithinResult = withinTextResult.evaluate(spillOffset, evalContext);
+        const spillStartNumResult = startNumResult.evaluate(spillOffset, evalContext);
+        if (!spillWithinResult || spillWithinResult.type === "error") {
+          return spillWithinResult;
+        }
+        if (!spillStartNumResult || spillStartNumResult.type === "error") {
+          return spillStartNumResult;
+        }
+        const result = findOperation(findTextResult, spillWithinResult, spillStartNumResult, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  } else if (startNumResult.type === "spilled-values" && findTextResult.type !== "spilled-values" && withinTextResult.type !== "spilled-values") {
+    if (findTextResult.type !== "value") {
+      return findTextResult;
+    }
+    if (withinTextResult.type !== "value") {
+      return withinTextResult;
+    }
+    if (findTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "FindText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (withinTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "WithinText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => startNumResult.spillArea(origin),
+      source: "FIND with spilled startNum values",
+      evaluate: (spillOffset, evalContext) => {
+        const spillResult = startNumResult.evaluate(spillOffset, evalContext);
+        if (!spillResult || spillResult.type === "error") {
+          return spillResult;
+        }
+        if (spillResult.type !== "value") {
+          return spillResult;
+        }
+        const startNumArg = {
+          type: "value",
+          result: spillResult.result
+        };
+        const result = findOperation(findTextResult, withinTextResult, startNumArg, evalContext);
+        if (result.type === "error" || result.type === "awaiting-evaluation") {
+          return result;
+        }
+        return {
+          type: "value",
+          result
+        };
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for FIND is not implemented");
+      }
+    };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: "Invalid arguments for FIND",
+    errAddress: context.dependencyNode
+  };
+}
+var FIND = {
+  name: "FIND",
+  evaluate: function(node, context) {
+    if (node.args.length < 2 || node.args.length > 3) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "FIND function takes 2 or 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const findTextResult = this.evaluateNode(node.args[0], context);
+    if (findTextResult.type === "error") {
+      return findTextResult;
+    }
+    const withinTextResult = this.evaluateNode(node.args[1], context);
+    if (withinTextResult.type === "error") {
+      return withinTextResult;
+    }
+    let startNumResult;
+    if (node.args.length > 2) {
+      startNumResult = this.evaluateNode(node.args[2], context);
+    } else {
+      startNumResult = {
+        type: "value",
+        result: { type: "number", value: 1 }
+      };
+    }
+    if (findTextResult.type === "spilled-values" || withinTextResult.type === "spilled-values" || startNumResult.type === "spilled-values") {
+      return createFindSpilledResult.call(this, {
+        findTextResult,
+        withinTextResult,
+        startNumResult,
+        context
+      });
+    }
+    if (findTextResult.type === "awaiting-evaluation") {
+      return findTextResult;
+    }
+    if (withinTextResult.type === "awaiting-evaluation") {
+      return withinTextResult;
+    }
+    if (findTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "FindText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (withinTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "WithinText argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = findOperation(findTextResult, withinTextResult, startNumResult, context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    return {
+      type: "value",
+      result
+    };
+  }
+};
+
+//# debugId=5159A9608D2C084264756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/find/find.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type ErrorEvaluationResult,\n} from \"src/core/types\";\nimport type { FormulaEngine } from \"src/core/engine\";\nimport { convertToString, extractNumericValue } from \"../text-helpers.cjs\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n// Helper function for FIND operation - returns the result, error, or null if not found\nfunction findOperation(\n  findTextResult: FunctionEvaluationResult,\n  withinTextResult: FunctionEvaluationResult,\n  startNumResult: FunctionEvaluationResult,\n  context: EvaluationContext\n): CellNumber | ErrorEvaluationResult {\n  const findStr = convertToString(findTextResult, context);\n  const withinStr = convertToString(withinTextResult, context);\n  const startNum = extractNumericValue(startNumResult, context);\n\n  // Check if any of the results are awaiting evaluation or errors\n  if (\n    typeof findStr === \"object\" &&\n    (findStr.type === \"awaiting-evaluation\" || findStr.type === \"error\")\n  ) {\n    return findStr;\n  }\n  if (\n    typeof withinStr === \"object\" &&\n    (withinStr.type === \"awaiting-evaluation\" || withinStr.type === \"error\")\n  ) {\n    return withinStr;\n  }\n  if (\n    typeof startNum === \"object\" &&\n    (startNum.type === \"awaiting-evaluation\" || startNum.type === \"error\")\n  ) {\n    return startNum;\n  }\n\n  // At this point, all values should be primitive types\n  const findValue = findStr as string;\n  const withinValue = withinStr as string;\n  const startNumValue = startNum as number;\n\n  // Validate startNum\n  if (startNumValue < 1) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Text not found #2\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const start = Math.floor(startNumValue) - 1; // Convert to 0-based index\n\n  if (start >= withinValue.length) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Text not found #2\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const index = withinValue.indexOf(findValue, start);\n  if (index === -1) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Text not found #2\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  return { type: \"number\", value: index + 1 }; // Convert back to 1-based index\n}\n\n/**\n * Helper for creating spilled-values result for FIND function\n */\nfunction createFindSpilledResult(\n  this: FormulaEvaluator,\n  {\n    findTextResult,\n    withinTextResult,\n    startNumResult,\n    context,\n  }: {\n    findTextResult: FunctionEvaluationResult;\n    withinTextResult: FunctionEvaluationResult;\n    startNumResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): FunctionEvaluationResult {\n  // If both findText and withinText are spilled-values, we need to zip them together\n  if (\n    findTextResult.type === \"spilled-values\" &&\n    withinTextResult.type === \"spilled-values\"\n  ) {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => {\n        // Create unified spill area (union of all spilled ranges)\n        let spillArea = this.unionRanges(\n          this.projectRange(findTextResult.spillArea(origin), origin),\n          this.projectRange(withinTextResult.spillArea(origin), origin)\n        );\n\n        // Also include startNum spill area if it's spilled\n        if (startNumResult.type === \"spilled-values\") {\n          spillArea = this.unionRanges(\n            spillArea,\n            this.projectRange(startNumResult.spillArea(origin), origin)\n          );\n        }\n        return spillArea;\n      },\n      source: \"FIND with zipped spilled findText and withinText values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        // Evaluate both spilled arrays at this position\n        const spillFindResult = findTextResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n        const spillWithinResult = withinTextResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n\n        if (!spillFindResult || spillFindResult.type === \"error\") {\n          return spillFindResult;\n        }\n        if (!spillWithinResult || spillWithinResult.type === \"error\") {\n          return spillWithinResult;\n        }\n\n        // Handle startNum - evaluate if spilled, otherwise use as-is\n        let startNumArg = startNumResult;\n        if (startNumResult.type === \"spilled-values\") {\n          const spillStartNumResult = startNumResult.evaluate(\n            spillOffset,\n            evalContext\n          );\n          if (!spillStartNumResult || spillStartNumResult.type === \"error\") {\n            return spillStartNumResult;\n          }\n          startNumArg = spillStartNumResult;\n        }\n\n        const result = findOperation(\n          spillFindResult,\n          spillWithinResult,\n          startNumArg,\n          evalContext\n        );\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  // If only findText is spilled-values\n  else if (\n    findTextResult.type === \"spilled-values\" &&\n    withinTextResult.type !== \"spilled-values\" &&\n    startNumResult.type !== \"spilled-values\"\n  ) {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => {\n        return findTextResult.spillArea(origin);\n      },\n      source: \"FIND with spilled findText values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        const spillResult = findTextResult.evaluate(spillOffset, evalContext);\n        if (!spillResult || spillResult.type === \"error\") {\n          return spillResult;\n        }\n        const result = findOperation(\n          spillResult,\n          withinTextResult,\n          startNumResult,\n          evalContext\n        );\n\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  // If only withinText is spilled-values\n  else if (\n    withinTextResult.type === \"spilled-values\" &&\n    findTextResult.type !== \"spilled-values\" &&\n    startNumResult.type !== \"spilled-values\"\n  ) {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin) => withinTextResult.spillArea(origin),\n      source: \"FIND with spilled withinText values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        const spillResult = withinTextResult.evaluate(spillOffset, evalContext);\n        if (!spillResult || spillResult.type === \"error\") {\n          return spillResult;\n        }\n        const result = findOperation(\n          findTextResult,\n          spillResult,\n          startNumResult,\n          evalContext\n        );\n\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  // If findText and startNum are spilled (but not withinText)\n  else if (\n    findTextResult.type === \"spilled-values\" &&\n    startNumResult.type === \"spilled-values\" &&\n    withinTextResult.type !== \"spilled-values\"\n  ) {\n    if (withinTextResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Invalid withinText argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Strict type checking\n    if (withinTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"WithinText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => {\n        // Create unified spill area (union of both ranges)\n        const spillArea = this.unionRanges(\n          this.projectRange(findTextResult.spillArea(origin), origin),\n          this.projectRange(startNumResult.spillArea(origin), origin)\n        );\n        return spillArea;\n      },\n      source: \"FIND with spilled findText and startNum values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        // Evaluate both spilled arrays at this position\n        const spillFindResult = findTextResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n        const spillStartNumResult = startNumResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n\n        if (!spillFindResult || spillFindResult.type === \"error\") {\n          return spillFindResult;\n        }\n        if (!spillStartNumResult || spillStartNumResult.type === \"error\") {\n          return spillStartNumResult;\n        }\n\n        const result = findOperation(\n          spillFindResult,\n          withinTextResult,\n          spillStartNumResult,\n          evalContext\n        );\n\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  // If withinText and startNum are spilled (but not findText)\n  else if (\n    withinTextResult.type === \"spilled-values\" &&\n    startNumResult.type === \"spilled-values\" &&\n    findTextResult.type !== \"spilled-values\"\n  ) {\n    if (findTextResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Invalid findText argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Strict type checking\n    if (findTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"FindText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => {\n        // Create unified spill area (union of both ranges)\n        const spillArea = this.unionRanges(\n          this.projectRange(withinTextResult.spillArea(origin), origin),\n          this.projectRange(startNumResult.spillArea(origin), origin)\n        );\n        return spillArea;\n      },\n      source: \"FIND with spilled withinText and startNum values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        // Evaluate both spilled arrays at this position\n        const spillWithinResult = withinTextResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n        const spillStartNumResult = startNumResult.evaluate(\n          spillOffset,\n          evalContext\n        );\n\n        if (!spillWithinResult || spillWithinResult.type === \"error\") {\n          return spillWithinResult;\n        }\n        if (!spillStartNumResult || spillStartNumResult.type === \"error\") {\n          return spillStartNumResult;\n        }\n\n        const result = findOperation(\n          findTextResult,\n          spillWithinResult,\n          spillStartNumResult,\n          evalContext\n        );\n\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  // If only startNum is spilled-values\n  else if (\n    startNumResult.type === \"spilled-values\" &&\n    findTextResult.type !== \"spilled-values\" &&\n    withinTextResult.type !== \"spilled-values\"\n  ) {\n    if (findTextResult.type !== \"value\") {\n      return findTextResult;\n    }\n    if (withinTextResult.type !== \"value\") {\n      return withinTextResult;\n    }\n\n    // Strict type checking\n    if (findTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"FindText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (withinTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"WithinText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => startNumResult.spillArea(origin),\n      source: \"FIND with spilled startNum values\",\n      evaluate: (spillOffset, evalContext: EvaluationContext) => {\n        const spillResult = startNumResult.evaluate(spillOffset, evalContext);\n        if (!spillResult || spillResult.type === \"error\") {\n          return spillResult;\n        }\n\n        // Create a proper startNum argument for findOperation\n        if (spillResult.type !== \"value\") {\n          return spillResult;\n        }\n        const startNumArg: ValueEvaluationResult = {\n          type: \"value\",\n          result: spillResult.result,\n        };\n\n        const result = findOperation(\n          findTextResult,\n          withinTextResult,\n          startNumArg,\n          evalContext\n        );\n\n        // Handle error or awaiting evaluation results\n        if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n          return result;\n        }\n        return {\n          type: \"value\",\n          result: result,\n        };\n      },\n      evaluateAllCells: (intersectingRange) => {\n        throw new Error(\"WIP: evaluateAllCells for FIND is not implemented\");\n      },\n    };\n  }\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid arguments for FIND\",\n    errAddress: context.dependencyNode,\n  };\n}\n\n/**\n * FIND function - Finds one text string within another (case-sensitive)\n *\n * Usage: FIND(find_text, within_text, [start_num])\n *\n * find_text: The text you want to find.\n * within_text: The text containing the text you want to find.\n * start_num: [Optional] The character at which to start the search (default: 1).\n *\n * Example: FIND(\"World\", \"Hello World\", 1) returns 7\n *\n * Note:\n * - The search is case-sensitive\n * - Returns the position of the first character of find_text within within_text\n * - Returns #VALUE! error if text is not found\n * - Supports dynamic arrays (spilled values) for find_text and within_text\n * - Strict type checking: text arguments must be strings, start_num must be number\n */\nexport const FIND: FunctionDefinition = {\n  name: \"FIND\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 2 || node.args.length > 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"FIND function takes 2 or 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate findText argument\n    const findTextResult = this.evaluateNode(node.args[0]!, context);\n    if (findTextResult.type === \"error\") {\n      return findTextResult;\n    }\n\n    // Evaluate withinText argument\n    const withinTextResult = this.evaluateNode(node.args[1]!, context);\n    if (withinTextResult.type === \"error\") {\n      return withinTextResult;\n    }\n\n    // Evaluate startNum argument (optional, defaults to 1)\n    let startNumResult: FunctionEvaluationResult;\n    if (node.args.length > 2) {\n      startNumResult = this.evaluateNode(node.args[2]!, context);\n    } else {\n      startNumResult = {\n        type: \"value\",\n        result: { type: \"number\", value: 1 },\n      };\n    }\n\n    // Handle spilled-values inputs - return spilled-values for spilling\n    if (\n      findTextResult.type === \"spilled-values\" ||\n      withinTextResult.type === \"spilled-values\" ||\n      startNumResult.type === \"spilled-values\"\n    ) {\n      return createFindSpilledResult.call(this, {\n        findTextResult,\n        withinTextResult,\n        startNumResult,\n        context,\n      });\n    }\n\n    if (findTextResult.type === \"awaiting-evaluation\") {\n      return findTextResult;\n    }\n    if (withinTextResult.type === \"awaiting-evaluation\") {\n      return withinTextResult;\n    }\n\n    // Strict type checking - no coercion\n    if (findTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"FindText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (withinTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"WithinText argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const result = findOperation(\n      findTextResult,\n      withinTextResult,\n      startNumResult,\n      context\n    );\n\n    // Handle error or awaiting evaluation results\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n\n    return {\n      type: \"value\",\n      result: result,\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "5159A9608D2C084264756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/left/left.cjs

@@ -0,0 +1,109 @@
+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/left/left.ts
+var exports_left = {};
+__export(exports_left, {
+  LEFT: () => LEFT
+});
+module.exports = __toCommonJS(exports_left);
+var import_types = require("src/core/types");
+var import_text_helpers = require("../text-helpers.cjs");
+var LEFT = {
+  name: "LEFT",
+  evaluate: function(node, context) {
+    if (node.args.length < 1 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "LEFT function takes 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error") {
+      return textResult;
+    }
+    let numCharsResult;
+    if (node.args.length > 1) {
+      numCharsResult = this.evaluateNode(node.args[1], context);
+      if (numCharsResult.type === "error") {
+        return numCharsResult;
+      }
+    } else {
+      numCharsResult = {
+        type: "value",
+        result: { type: "number", value: 1 }
+      };
+    }
+    const startNumResult = {
+      type: "value",
+      result: { type: "number", value: 1 }
+    };
+    if (textResult.type === "spilled-values" || numCharsResult.type === "spilled-values") {
+      return import_text_helpers.createMidSpilledResult.call(this, {
+        textResult,
+        startNumResult,
+        numCharsResult,
+        context
+      });
+    }
+    if (textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    if (numCharsResult.type === "awaiting-evaluation") {
+      return numCharsResult;
+    }
+    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
+      };
+    }
+    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=5DF7F73BD93E071864756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/left/left.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 * LEFT function - Returns the leftmost characters from a text string\n *\n * Usage: LEFT(text, num_chars)\n *\n * text: The text string to extract characters from.\n * num_chars: The number of characters to extract from the left side of the text.\n *\n * Example: LEFT(\"Hello, World!\", 5) returns \"Hello\"\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, 1, num_chars)\n */\nexport const LEFT: FunctionDefinition = {\n  name: \"LEFT\",\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: \"LEFT 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 (textResult.type === \"error\") {\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 (numCharsResult.type === \"error\") {\n        return numCharsResult;\n      }\n    } else {\n      numCharsResult = {\n        type: \"value\",\n        result: { type: \"number\", value: 1 },\n      };\n    }\n\n    // Create start_num argument (always 1 for LEFT)\n    const startNumResult: FunctionEvaluationResult = {\n      type: \"value\",\n      result: { type: \"number\", value: 1 },\n    };\n\n    // Handle spilled-values inputs using MID's spilled result handler\n    if (textResult.type === \"spilled-values\" || numCharsResult.type === \"spilled-values\") {\n      return createMidSpilledResult.call(this, {\n        textResult,\n        startNumResult,\n        numCharsResult,\n        context,\n      });\n    }\n\n    // Both arguments are single values\n    if (textResult.type === \"awaiting-evaluation\") {\n      return textResult;\n    }\n\n    if (numCharsResult.type === \"awaiting-evaluation\") {\n      return numCharsResult;\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 MID operation: LEFT(text, num_chars) = MID(text, 1, num_chars)\n    const result = midOperation(textResult, startNumResult, numCharsResult, context);\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};"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AAKqD,IAArD;AAmBO,IAAM,OAA2B;AAAA,EACtC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,SAAS,GAAG;AAAA,MAChD,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,IAAI,WAAW,SAAS,SAAS;AAAA,MAC/B,OAAO;AAAA,IACT;AAAA,IAGA,IAAI;AAAA,IACJ,IAAI,KAAK,KAAK,SAAS,GAAG;AAAA,MACxB,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MACzD,IAAI,eAAe,SAAS,SAAS;AAAA,QACnC,OAAO;AAAA,MACT;AAAA,IACF,EAAO;AAAA,MACL,iBAAiB;AAAA,QACf,MAAM;AAAA,QACN,QAAQ,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,MACrC;AAAA;AAAA,IAIF,MAAM,iBAA2C;AAAA,MAC/C,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,IACrC;AAAA,IAGA,IAAI,WAAW,SAAS,oBAAoB,eAAe,SAAS,kBAAkB;AAAA,MACpF,OAAO,2CAAuB,KAAK,MAAM;AAAA,QACvC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAGA,IAAI,WAAW,SAAS,uBAAuB;AAAA,MAC7C,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,uBAAuB;AAAA,MACjD,OAAO;AAAA,IACT;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,IAGA,MAAM,SAAS,iCAAa,YAAY,gBAAgB,gBAAgB,OAAO;AAAA,IAC/E,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": "5DF7F73BD93E071864756E2164756E21",
+  "names": []
+}