@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/lookup/count/countif.cjs

@@ -0,0 +1,94 @@
+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/lookup/count/countif.ts
+var exports_countif = {};
+__export(exports_countif, {
+  COUNTIF: () => COUNTIF
+});
+module.exports = __toCommonJS(exports_countif);
+var import_types = require("src/core/types");
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_criteria_parser = require("../../criteria-parser.cjs");
+var import_count_utils = require("./count-utils.cjs");
+var COUNTIF = {
+  name: "COUNTIF",
+  evaluate: function(node, context) {
+    if (node.args.length !== 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "COUNTIF function takes exactly 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const criteriaRangeResult = this.evaluateNode(node.args[0], context);
+    if (criteriaRangeResult.type === "error" || criteriaRangeResult.type === "awaiting-evaluation") {
+      return criteriaRangeResult;
+    }
+    const criteriaResult = this.evaluateNode(node.args[1], context);
+    if (criteriaResult.type === "error" || criteriaResult.type === "awaiting-evaluation") {
+      return criteriaResult;
+    }
+    if (criteriaResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "COUNTIF criteria must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const parsedCriteria = import_criteria_parser.parseCriteria(criteriaResult.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: parsedCriteria.message,
+        errAddress: context.dependencyNode
+      };
+    }
+    const countingEmptyCells = import_count_utils.countEmptyCells(criteriaRangeResult, parsedCriteria, context.cellAddress);
+    if (countingEmptyCells) {
+      return countingEmptyCells;
+    }
+    let count = 0;
+    const results = import_criteria_utils.processMultiCriteriaValues(this, criteriaRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (results.type === "error" || results.type === "awaiting-evaluation") {
+      return results;
+    }
+    for (const result of results.values) {
+      count++;
+    }
+    return {
+      type: "value",
+      result: { type: "number", value: count }
+    };
+  }
+};
+
+//# debugId=E5E88BF422DBEF6F64756E2164756E21

package/dist/cjs/functions/lookup/count/countif.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/count/countif.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  processMultiCriteriaValues,\n  validateSingleCriteriaArgs,\n} from \"../../criteria-utils.cjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.cjs\";\nimport { countEmptyCells } from \"./count-utils.cjs\";\n\n/**\n * COUNTIF function - Counts cells in a range that meet a criteria\n *\n * Usage: COUNTIF(range, criteria)\n *\n * range: The range of cells to evaluate\n * criteria: The criteria to match against. Can be:\n *   - Exact value: \"Apple\", 42\n *   - Comparison: \">10\", \"<=5\", \"<>0\"\n *   - Wildcards: \"App*\", \"?ruit\"\n *\n * Examples:\n *   COUNTIF(A1:A10, \"Apple\") - counts cells containing \"Apple\"\n *   COUNTIF(B1:B10, \">10\") - counts cells with values greater than 10\n *   COUNTIF(C1:C10, \"App*\") - counts cells starting with \"App\"\n *\n * Note:\n * - Supports type coercion for comparisons\n * - Case-sensitive string matching\n * - Wildcards: * matches any sequence, ? matches any single character\n */\n\n/**\n * COUNTIF function implementation\n */\nexport const COUNTIF: FunctionDefinition = {\n  name: \"COUNTIF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments - COUNTIF takes exactly 2 arguments\n    if (node.args.length !== 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COUNTIF function takes exactly 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate criteria range (first argument)\n    const criteriaRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (criteriaRangeResult.type === \"error\" || criteriaRangeResult.type === \"awaiting-evaluation\") {\n      return criteriaRangeResult;\n    }\n\n    // Evaluate criteria (second argument)\n    const criteriaResult = this.evaluateNode(node.args[1]!, context);\n    if (criteriaResult.type === \"error\" || criteriaResult.type === \"awaiting-evaluation\") {\n      return criteriaResult;\n    }\n\n    if (criteriaResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COUNTIF criteria must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Parse criteria\n    const parsedCriteria = parseCriteria(criteriaResult.result);\n    if (parsedCriteria.type === \"error\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: parsedCriteria.message,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Special case: counting empty cells over infinite ranges\n    const countingEmptyCells = countEmptyCells(\n      criteriaRangeResult,\n      parsedCriteria,\n      context.cellAddress\n    );\n    if (countingEmptyCells) {\n      return countingEmptyCells;\n    }\n\n    // Use shared criteria processing - count all matching values (including non-numeric)\n    let count = 0;\n\n    const results = processMultiCriteriaValues(\n      this,\n      criteriaRangeResult,\n      [{ rangeResult: criteriaRangeResult, parsedCriteria }],\n      context,\n      \"col-major\"\n    );\n\n    if (results.type === \"error\" || results.type === \"awaiting-evaluation\") {\n      return results;\n    }\n\n    for (const result of results.values) {\n      // COUNTIF counts all matching cells, including errors and non-numeric values\n      count++;\n    }\n\n    return {\n      type: \"value\",\n      result: { type: \"number\", value: count },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AASO,IAHP;AAIqD,IAArD;AACgC,IAAhC;AA2BO,IAAM,UAA8B;AAAA,EACzC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,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,sBAAsB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACpE,IAAI,oBAAoB,SAAS,WAAW,oBAAoB,SAAS,uBAAuB;AAAA,MAC9F,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,qCAAc,eAAe,MAAM;AAAA,IAC1D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,eAAe;AAAA,QACxB,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,qBAAqB,mCACzB,qBACA,gBACA,QAAQ,WACV;AAAA,IACA,IAAI,oBAAoB;AAAA,MACtB,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,QAAQ;AAAA,IAEZ,MAAM,UAAU,iDACd,MACA,qBACA,CAAC,EAAE,aAAa,qBAAqB,eAAe,CAAC,GACrD,SACA,WACF;AAAA,IAEA,IAAI,QAAQ,SAAS,WAAW,QAAQ,SAAS,uBAAuB;AAAA,MACtE,OAAO;AAAA,IACT;AAAA,IAEA,WAAW,UAAU,QAAQ,QAAQ;AAAA,MAEnC;AAAA,IACF;AAAA,IAEA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,UAAU,OAAO,MAAM;AAAA,IACzC;AAAA;AAEJ;",
+  "debugId": "E5E88BF422DBEF6F64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/lookup/count/countifs.cjs

@@ -0,0 +1,63 @@
+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/lookup/count/countifs.ts
+var exports_countifs = {};
+__export(exports_countifs, {
+  COUNTIFS: () => COUNTIFS
+});
+module.exports = __toCommonJS(exports_countifs);
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var COUNTIFS = {
+  name: "COUNTIFS",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateCountifsArgs(node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const criteriaPairsResult = import_criteria_utils.parseCriteriaPairs.call(this, node, context, this.evaluateNode, 0);
+    if ("type" in criteriaPairsResult) {
+      return criteriaPairsResult;
+    }
+    const countRangeResult = criteriaPairsResult[0].rangeResult;
+    let count = 0;
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, countRangeResult, criteriaPairsResult, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    for (const result of matchingValues.values) {
+      count++;
+    }
+    return {
+      type: "value",
+      result: { type: "number", value: count }
+    };
+  }
+};
+
+//# debugId=E149D62B1FFDA36C64756E2164756E21

package/dist/cjs/functions/lookup/count/countifs.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/count/countifs.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport { \n  parseCriteriaPairs, \n  processMultiCriteriaValues, \n  validateCountifsArgs \n} from \"../../criteria-utils.cjs\";\n\n/**\n * COUNTIFS function - Counts cells that meet multiple criteria\n * \n * Usage: COUNTIFS(criteria_range1, criteria1, [criteria_range2, criteria2], ...)\n * \n * criteria_range1: The first range to evaluate against criteria1\n * criteria1: The first criteria to match against\n * criteria_range2, criteria2: Optional additional criteria pairs\n * \n * Examples:\n *   COUNTIFS(A1:A10, \"Apple\") - counts cells in A1:A10 that equal \"Apple\"\n *   COUNTIFS(A1:A10, \"Apple\", B1:B10, \">10\") - counts where A1:A10 = \"Apple\" AND B1:B10 > 10\n * \n * Note:\n * - All criteria must be satisfied for a cell to be counted\n * - Counts all matching cells, not just numeric ones\n * - Returns 0 if no cells match all criteria\n * - Unlike other IFS functions, COUNTIFS counts the first criteria range itself\n */\nexport const COUNTIFS: FunctionDefinition = {\n  name: \"COUNTIFS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateCountifsArgs(node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Parse criteria pairs starting from argument 0 (COUNTIFS has different syntax)\n    const criteriaPairsResult = parseCriteriaPairs.call(this, node, context, this.evaluateNode, 0);\n    if ('type' in criteriaPairsResult) {\n      return criteriaPairsResult;\n    }\n\n    // The first criteria range is what we count\n    const countRangeResult = criteriaPairsResult[0]!.rangeResult;\n\n    // Process values with criteria using generator - count all matching cells (including non-numeric)\n    let count = 0;\n\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      countRangeResult,\n      criteriaPairsResult,\n      context,\n      \"col-major\"\n    );\n    \n    if (matchingValues.type === \"error\" || matchingValues.type === \"awaiting-evaluation\") {\n      return matchingValues;\n    }\n\n    for (const result of matchingValues.values) {\n      // COUNTIFS counts all matching cells, including errors and non-numeric values\n      count++;\n    }\n\n    return {\n      type: \"value\",\n      result: { type: \"number\", value: count },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUO,IAJP;AAyBO,IAAM,WAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,2CAAqB,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC/D,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,yCAAmB,KAAK,MAAM,MAAM,SAAS,KAAK,cAAc,CAAC;AAAA,IAC7F,IAAI,UAAU,qBAAqB;AAAA,MACjC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,mBAAmB,oBAAoB,GAAI;AAAA,IAGjD,IAAI,QAAQ;AAAA,IAEZ,MAAM,iBAAiB,iDACrB,MACA,kBACA,qBACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,WAAW,UAAU,eAAe,QAAQ;AAAA,MAE1C;AAAA,IACF;AAAA,IAEA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,UAAU,OAAO,MAAM;AAAA,IACzC;AAAA;AAEJ;",
+  "debugId": "E149D62B1FFDA36C64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/lookup/index-lookup/index-lookup.cjs

@@ -0,0 +1,187 @@
+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/lookup/index-lookup/index-lookup.ts
+var exports_index_lookup = {};
+__export(exports_index_lookup, {
+  INDEX: () => INDEX
+});
+module.exports = __toCommonJS(exports_index_lookup);
+var import_types = require("src/core/types");
+function getValueFromArray(arrayResult, row, col, context) {
+  const dims = arrayResult.spillArea(context.cellAddress);
+  const rowIndex = row - 1;
+  const colIndex = col - 1;
+  const actualRow = dims.start.row + rowIndex;
+  const actualCol = dims.start.col + colIndex;
+  if (actualRow < 0 || dims.end.row.type === "number" && actualRow > dims.end.row.value) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.REF,
+      message: `INDEX: row_num ${row} is out of range`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (actualCol < 0 || dims.end.col.type === "number" && actualCol > dims.end.col.value) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.REF,
+      message: `INDEX: column_num ${col} is out of range`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const spilledAddress = {
+    colIndex: actualCol,
+    rowIndex: actualRow,
+    sheetName: context.cellAddress.sheetName,
+    workbookName: context.cellAddress.workbookName
+  };
+  const spill = {
+    address: spilledAddress,
+    spillOffset: {
+      x: actualCol - dims.start.col,
+      y: actualRow - dims.start.row
+    }
+  };
+  const spillResult = arrayResult.evaluate(spill.spillOffset, context);
+  if (!spillResult) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "INDEX: Unable to retrieve value from array",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (spillResult.type === "error" || spillResult.type === "awaiting-evaluation") {
+    return spillResult;
+  }
+  return spillResult.result;
+}
+var INDEX = {
+  name: "INDEX",
+  evaluate: function(node, context) {
+    if (node.args.length < 2 || node.args.length > 3) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDEX function takes 2 or 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const arrayResult = this.evaluateNode(node.args[0], context);
+    if (arrayResult.type === "error" || arrayResult.type === "awaiting-evaluation") {
+      return arrayResult;
+    }
+    const rowNumResult = this.evaluateNode(node.args[1], context);
+    if (rowNumResult.type === "error" || rowNumResult.type === "awaiting-evaluation") {
+      return rowNumResult;
+    }
+    let colNumResult = null;
+    if (node.args[2]) {
+      colNumResult = this.evaluateNode(node.args[2], context);
+      if (colNumResult.type === "error" || colNumResult.type === "awaiting-evaluation") {
+        return colNumResult;
+      }
+    }
+    if (rowNumResult.type === "spilled-values" || colNumResult && colNumResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDEX: Spilled row_num/column_num arguments not yet implemented",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (rowNumResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `INDEX row_num must be number, got ${rowNumResult.result.type}`,
+        errAddress: context.dependencyNode
+      };
+    }
+    const colNumValue = colNumResult?.result;
+    if (colNumValue && colNumValue.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `INDEX column_num must be number, got ${colNumValue.type}`,
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowNum = Math.floor(rowNumResult.result.value);
+    const colNum = colNumValue ? Math.floor(colNumValue.value) : 1;
+    if (rowNum < 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `INDEX row_num must be >= 1, got ${rowNum}`,
+        errAddress: context.dependencyNode
+      };
+    }
+    if (colNum < 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `INDEX column_num must be >= 1, got ${colNum}`,
+        errAddress: context.dependencyNode
+      };
+    }
+    if (arrayResult.type === "value") {
+      if (rowNum !== 1 || colNum !== 1) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: `INDEX: Single value can only be accessed at [1,1], got [${rowNum},${colNum}]`,
+          errAddress: context.dependencyNode
+        };
+      }
+      return {
+        type: "value",
+        result: arrayResult.result
+      };
+    } else if (arrayResult.type === "spilled-values") {
+      const result = getValueFromArray.call(this, arrayResult, rowNum, colNum, context);
+      if (result.type === "error" || result.type === "awaiting-evaluation") {
+        return result;
+      }
+      return {
+        type: "value",
+        result
+      };
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDEX: Invalid array argument type",
+        errAddress: context.dependencyNode
+      };
+    }
+  }
+};
+
+//# debugId=727C46D4F1FB23A264756E2164756E21

package/dist/cjs/functions/lookup/index-lookup/index-lookup.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/index-lookup/index-lookup.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type SpilledValuesEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type ErrorEvaluationResult,\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 * INDEX function - Returns a value from a table or array\n * INDEX(array, row_num, [column_num])\n *\n * STRICT TYPE CHECKING:\n * - array: range/array only\n * - row_num: number only (integer, 1-based)\n * - column_num: number only (integer, 1-based, optional)\n *\n * If array is 1-dimensional (single row or column):\n * - Only row_num is used (treats as a linear array)\n * - column_num is ignored if provided\n *\n * If array is 2-dimensional:\n * - Both row_num and column_num can be used\n * - If column_num is omitted, returns entire row\n */\n\n// Helper function to get value from array at specific position\nfunction getValueFromArray(\n  this: FormulaEvaluator,\n  arrayResult: SpilledValuesEvaluationResult,\n  row: number,\n  col: number,\n  context: EvaluationContext\n): CellValue | ErrorEvaluationResult {\n  const dims = arrayResult.spillArea(context.cellAddress);\n\n  // Convert 1-based indices to 0-based\n  const rowIndex = row - 1;\n  const colIndex = col - 1;\n\n  // Calculate actual cell position\n  const actualRow = dims.start.row + rowIndex;\n  const actualCol = dims.start.col + colIndex;\n\n  // Check bounds\n  if (\n    actualRow < 0 ||\n    (dims.end.row.type === \"number\" && actualRow > dims.end.row.value)\n  ) {\n    return {\n      type: \"error\",\n      err: FormulaError.REF,\n      message: `INDEX: row_num ${row} is out of range`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (\n    actualCol < 0 ||\n    (dims.end.col.type === \"number\" && actualCol > dims.end.col.value)\n  ) {\n    return {\n      type: \"error\",\n      err: FormulaError.REF,\n      message: `INDEX: column_num ${col} is out of range`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const spilledAddress: CellAddress = {\n    colIndex: actualCol,\n    rowIndex: actualRow,\n    sheetName: context.cellAddress.sheetName,\n    workbookName: context.cellAddress.workbookName,\n  };\n\n  const spill = {\n    address: spilledAddress,\n    spillOffset: {\n      x: actualCol - dims.start.col,\n      y: actualRow - dims.start.row,\n    },\n  };\n\n  const spillResult = arrayResult.evaluate(spill.spillOffset, context);\n\n  if (!spillResult) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"INDEX: Unable to retrieve value from array\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (\n    spillResult.type === \"error\" ||\n    spillResult.type === \"awaiting-evaluation\"\n  ) {\n    return spillResult;\n  }\n\n  return spillResult.result;\n}\n\nexport const INDEX: FunctionDefinition = {\n  name: \"INDEX\",\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: \"INDEX function takes 2 or 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate array argument\n    const arrayResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      arrayResult.type === \"error\" ||\n      arrayResult.type === \"awaiting-evaluation\"\n    ) {\n      return arrayResult;\n    }\n\n    // Evaluate row_num argument\n    const rowNumResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      rowNumResult.type === \"error\" ||\n      rowNumResult.type === \"awaiting-evaluation\"\n    ) {\n      return rowNumResult;\n    }\n\n    // Evaluate column_num argument (optional)\n    let colNumResult: FunctionEvaluationResult | null = null;\n    if (node.args[2]) {\n      colNumResult = this.evaluateNode(node.args[2], context);\n      if (\n        colNumResult.type === \"error\" ||\n        colNumResult.type === \"awaiting-evaluation\"\n      ) {\n        return colNumResult;\n      }\n    }\n\n    // Handle spilled arrays for row_num and col_num (not array which is expected to be a range)\n    if (\n      rowNumResult.type === \"spilled-values\" ||\n      (colNumResult && colNumResult.type === \"spilled-values\")\n    ) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message:\n          \"INDEX: Spilled row_num/column_num arguments not yet implemented\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Strict type checking for row_num\n    if (rowNumResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `INDEX row_num must be number, got ${rowNumResult.result.type}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const colNumValue = colNumResult?.result;\n\n    // Strict type checking for column_num if provided\n    if (colNumValue && colNumValue.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `INDEX column_num must be number, got ${colNumValue.type}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Extract row and column numbers (convert to integers)\n    const rowNum = Math.floor(rowNumResult.result.value);\n    const colNum = colNumValue ? Math.floor(colNumValue.value) : 1;\n\n    // Validate that indices are positive\n    if (rowNum < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `INDEX row_num must be >= 1, got ${rowNum}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (colNum < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `INDEX column_num must be >= 1, got ${colNum}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Handle different array result types\n    if (arrayResult.type === \"value\") {\n      // Single value case - can only access [1,1]\n      if (rowNum !== 1 || colNum !== 1) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: `INDEX: Single value can only be accessed at [1,1], got [${rowNum},${colNum}]`,\n          errAddress: context.dependencyNode,\n        };\n      }\n      return {\n        type: \"value\",\n        result: arrayResult.result,\n      } satisfies ValueEvaluationResult;\n    } else if (arrayResult.type === \"spilled-values\") {\n      // Array case - use helper function to get value\n      const result = getValueFromArray.call(\n        this,\n        arrayResult,\n        rowNum,\n        colNum,\n        context\n      );\n\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n\n      return {\n        type: \"value\",\n        result,\n      } satisfies ValueEvaluationResult;\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"INDEX: Invalid array argument type\",\n        errAddress: context.dependencyNode,\n      };\n    }\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "727C46D4F1FB23A264756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/lookup/match/match.cjs

@@ -0,0 +1,168 @@
+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/lookup/match/match.ts
+var exports_match = {};
+__export(exports_match, {
+  MATCH: () => MATCH
+});
+module.exports = __toCommonJS(exports_match);
+var import_types = require("src/core/types");
+function matchOperation(lookupValue, lookupArray, matchType, context, isHorizontal) {
+  if (lookupValue.type !== "string" && lookupValue.type !== "number") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `MATCH lookup_value must be string or number, got ${lookupValue.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (matchType !== -1 && matchType !== 0 && matchType !== 1) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `MATCH match_type must be -1, 0, or 1, got ${matchType}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (lookupArray.type === "awaiting-evaluation" || lookupArray.type === "error") {
+    return lookupArray;
+  }
+  for (const value of lookupArray.values) {
+    if (value.result.type === "value") {
+      if (matchType === 0) {
+        const arrayValue = value.result.result;
+        if (arrayValue.type === lookupValue.type && arrayValue.value === lookupValue.value) {
+          const position = isHorizontal ? value.relativePos.x + 1 : value.relativePos.y + 1;
+          return {
+            type: "value",
+            result: { type: "number", value: position }
+          };
+        }
+      } else {
+        throw new Error("MATCH: approximate match not fully implemented");
+      }
+    }
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.NA,
+    message: "MATCH: lookup_value not found in lookup_array",
+    errAddress: context.dependencyNode
+  };
+}
+var MATCH = {
+  name: "MATCH",
+  evaluate: function(node, context) {
+    if (node.args.length < 2 || node.args.length > 3) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "MATCH function takes 2 or 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const lookupValueResult = this.evaluateNode(node.args[0], context);
+    if (lookupValueResult.type === "error" || lookupValueResult.type === "awaiting-evaluation") {
+      return lookupValueResult;
+    }
+    const lookupArrayResult = this.evaluateNode(node.args[1], context);
+    if (lookupArrayResult.type === "error" || lookupArrayResult.type === "awaiting-evaluation") {
+      return lookupArrayResult;
+    }
+    let matchTypeResult = {
+      type: "value",
+      result: { type: "number", value: 1 }
+    };
+    if (node.args[2]) {
+      matchTypeResult = this.evaluateNode(node.args[2], context);
+      if (matchTypeResult.type === "error" || matchTypeResult.type === "awaiting-evaluation") {
+        return matchTypeResult;
+      }
+    }
+    if (lookupValueResult.type === "spilled-values" || matchTypeResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "MATCH: Spilled array arguments not yet implemented",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (matchTypeResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `MATCH match_type must be number, got ${matchTypeResult.result.type}`,
+        errAddress: context.dependencyNode
+      };
+    }
+    let lookupArray = {
+      type: "awaiting-evaluation",
+      waitingFor: context.dependencyNode,
+      errAddress: context.dependencyNode
+    };
+    let isHorizontal = false;
+    if (lookupArrayResult.type === "value") {
+      lookupArray = {
+        type: "values",
+        values: [{ result: lookupArrayResult, relativePos: { x: 0, y: 0 } }]
+      };
+      isHorizontal = false;
+    } else if (lookupArrayResult.type === "spilled-values") {
+      const spillArea = lookupArrayResult.spillArea(context.cellAddress);
+      const startRow = spillArea.start.row;
+      const endRow = spillArea.end.row;
+      const startCol = spillArea.start.col;
+      const endCol = spillArea.end.col;
+      const isSingleRow = endRow.type === "number" && startRow === endRow.value;
+      const isSingleCol = endCol.type === "number" && startCol === endCol.value;
+      if (!isSingleRow && !isSingleCol) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "MATCH lookup_array must be a single row or single column (1D array)",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (isSingleRow && isSingleCol) {
+        isHorizontal = false;
+      } else {
+        isHorizontal = isSingleRow;
+      }
+      lookupArray = lookupArrayResult.evaluateAllCells.call(this, {
+        context,
+        evaluate: lookupArrayResult.evaluate,
+        origin: context.cellAddress,
+        lookupOrder: "col-major"
+      });
+    }
+    return matchOperation(lookupValueResult.result, lookupArray, Math.floor(matchTypeResult.result.value), context, isHorizontal);
+  }
+};
+
+//# debugId=AA86A60C3D723EEA64756E2164756E21

package/dist/cjs/functions/lookup/match/match.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/match/match.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type EvaluateAllCellsResult,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * MATCH function - Returns the position of a value in an array\n * MATCH(lookup_value, lookup_array, [match_type])\n * match_type: 1 = less than or equal (default), 0 = exact match, -1 = greater than or equal\n *\n * STRICT TYPE CHECKING:\n * - lookup_value: string or number only\n * - lookup_array: array of strings or numbers only\n * - match_type: number only (must be -1, 0, or 1)\n */\n\n// Helper function to perform MATCH operation\nfunction matchOperation(\n  lookupValue: CellValue,\n  lookupArray: EvaluateAllCellsResult,\n  matchType: number,\n  context: EvaluationContext,\n  isHorizontal: boolean\n): FunctionEvaluationResult {\n  // Strict type checking for lookup_value\n  if (lookupValue.type !== \"string\" && lookupValue.type !== \"number\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `MATCH lookup_value must be string or number, got ${lookupValue.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Validate match_type\n  if (matchType !== -1 && matchType !== 0 && matchType !== 1) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `MATCH match_type must be -1, 0, or 1, got ${matchType}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n  if (\n    lookupArray.type === \"awaiting-evaluation\" ||\n    lookupArray.type === \"error\"\n  ) {\n    return lookupArray;\n  }\n\n  for (const value of lookupArray.values) {\n    if (value.result.type === \"value\") {\n      if (matchType === 0) {\n        // Exact match\n        const arrayValue = value.result.result;\n\n        if (\n          arrayValue.type === lookupValue.type &&\n          arrayValue.value === lookupValue.value\n        ) {\n          // For horizontal arrays (single row), use x position (column index)\n          // For vertical arrays (single/multiple columns), use y position (row index)\n          const position = isHorizontal\n            ? value.relativePos.x + 1\n            : value.relativePos.y + 1;\n\n          return {\n            type: \"value\",\n            result: { type: \"number\", value: position },\n          }; // 1-based index\n        }\n      } else {\n        // Approximate match (1 or -1) - requires sorted array\n        // For now, throw an error until we add sorting validation\n        // TODO: Add proper approximate match logic with sorted array validation\n        throw new Error(\"MATCH: approximate match not fully implemented\");\n      }\n    }\n  }\n\n  return {\n    type: \"error\",\n    err: FormulaError.NA,\n    message: \"MATCH: lookup_value not found in lookup_array\",\n    errAddress: context.dependencyNode,\n  };\n}\n\nexport const MATCH: FunctionDefinition = {\n  name: \"MATCH\",\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: \"MATCH function takes 2 or 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate lookup_value\n    const lookupValueResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      lookupValueResult.type === \"error\" ||\n      lookupValueResult.type === \"awaiting-evaluation\"\n    ) {\n      return lookupValueResult;\n    }\n\n    // Evaluate lookup_array\n    const lookupArrayResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      lookupArrayResult.type === \"error\" ||\n      lookupArrayResult.type === \"awaiting-evaluation\"\n    ) {\n      return lookupArrayResult;\n    }\n\n    // Evaluate match_type (optional, defaults to 1)\n    let matchTypeResult: FunctionEvaluationResult = {\n      type: \"value\",\n      result: { type: \"number\", value: 1 },\n    };\n\n    if (node.args[2]) {\n      matchTypeResult = this.evaluateNode(node.args[2], context);\n      if (\n        matchTypeResult.type === \"error\" ||\n        matchTypeResult.type === \"awaiting-evaluation\"\n      ) {\n        return matchTypeResult;\n      }\n    }\n\n    // Handle spilled arrays for lookup_value and match_type (not lookup_array which is expected to be a range)\n    if (\n      lookupValueResult.type === \"spilled-values\" ||\n      matchTypeResult.type === \"spilled-values\"\n    ) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"MATCH: Spilled array arguments not yet implemented\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Strict type checking for match_type\n    if (matchTypeResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `MATCH match_type must be number, got ${matchTypeResult.result.type}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Extract lookup_array values\n    let lookupArray: EvaluateAllCellsResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: context.dependencyNode,\n      errAddress: context.dependencyNode,\n    };\n    let isHorizontal = false;\n\n    // Handle direct range arguments (like A:A) before extracting lookup_array values\n\n    // Extract lookup_array values for non-infinite ranges\n    if (lookupArrayResult.type === \"value\") {\n      // Single value case - treat as array with one element\n      lookupArray = {\n        type: \"values\",\n        values: [{ result: lookupArrayResult, relativePos: { x: 0, y: 0 } }],\n      };\n      isHorizontal = false; // Single value, treat as vertical\n    } else if (lookupArrayResult.type === \"spilled-values\") {\n      // Validate that lookup_array is 1D (either single row OR single column)\n      const spillArea = lookupArrayResult.spillArea(context.cellAddress);\n      const startRow = spillArea.start.row;\n      const endRow = spillArea.end.row;\n      const startCol = spillArea.start.col;\n      const endCol = spillArea.end.col;\n\n      // Check if it's a single row (horizontal)\n      const isSingleRow = endRow.type === \"number\" && startRow === endRow.value;\n\n      // Check if it's a single column (vertical)\n      const isSingleCol = endCol.type === \"number\" && startCol === endCol.value;\n\n      // MATCH requires a 1D array - either single row OR single column, not both or neither\n      if (!isSingleRow && !isSingleCol) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message:\n            \"MATCH lookup_array must be a single row or single column (1D array)\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      // Cannot be both single row AND single column (that would be a single cell, which is handled)\n      if (isSingleRow && isSingleCol) {\n        // This is actually a single cell, which is fine\n        isHorizontal = false; // Treat single cell as vertical\n      } else {\n        // Horizontal if it's a single row\n        isHorizontal = isSingleRow;\n      }\n\n      // Extract values from spilled array\n      lookupArray = lookupArrayResult.evaluateAllCells.call(this, {\n        context,\n        evaluate: lookupArrayResult.evaluate,\n        origin: context.cellAddress,\n        lookupOrder: \"col-major\",\n      });\n    }\n\n    // Perform MATCH operation\n    return matchOperation(\n      lookupValueResult.result,\n      lookupArray,\n      Math.floor(matchTypeResult.result.value), // Floor to handle decimal inputs\n      context,\n      isHorizontal\n    );\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "AA86A60C3D723EEA64756E2164756E21",
+  "names": []
+}