@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/array/sequence/sequence.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/array/sequence/sequence.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellAddress,\n  type CellInRangeResult,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type SpilledValuesEvaluationResult,\n  type SpreadsheetRange,\n} from \"src/core/types\";\nimport { getRangeIntersection, isRangeOneCell } from \"src/core/utils\";\nimport { EvaluationError } from \"src/evaluator/evaluation-error\";\n\n/**\n * SEQUENCE(rows, [columns], [start], [step])\n * Generates a sequence of numbers in an array.\n *\n * @param rows - The number of rows to return (can be array - uses origin value)\n * @param columns - [Optional] The number of columns to return (default: 1, can be array - uses origin value)\n * @param start - [Optional] The first number in the sequence (default: 1, can be array - uses origin value)\n * @param step - [Optional] The amount to increment each subsequent value (default: 1, can be array - uses origin value)\n *\n * Returns a spilled array of sequential numbers.\n * When any argument is an array, the result is broadcast over the largest input spill area.\n */\nexport const SEQUENCE: FunctionDefinition = {\n  name: \"SEQUENCE\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 1 || node.args.length > 4) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"SEQUENCE function takes 1 to 4 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate all arguments and check for array inputs\n    const argResults: FunctionEvaluationResult[] = [];\n    let largestSpillArea: SpreadsheetRange | null = null;\n    let hasArrayInput = false;\n\n    for (let i = 0; i < node.args.length; i++) {\n      const result = this.evaluateNode(node.args[i]!, context);\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      argResults.push(result);\n\n      if (result.type === \"spilled-values\") {\n        hasArrayInput = true;\n        const spillArea = result.spillArea(context.cellAddress);\n        if (!largestSpillArea) {\n          largestSpillArea = spillArea;\n        } else {\n          // Use the larger spill area (more cells)\n          const currentCols =\n            spillArea.end.col.type === \"number\"\n              ? spillArea.end.col.value\n              : Infinity;\n          const currentRows =\n            spillArea.end.row.type === \"number\"\n              ? spillArea.end.row.value\n              : Infinity;\n          const currentSize =\n            (currentCols - spillArea.start.col + 1) *\n            (currentRows - spillArea.start.row + 1);\n\n          const largestCols =\n            largestSpillArea.end.col.type === \"number\"\n              ? largestSpillArea.end.col.value\n              : Infinity;\n          const largestRows =\n            largestSpillArea.end.row.type === \"number\"\n              ? largestSpillArea.end.row.value\n              : Infinity;\n          const largestSize =\n            (largestCols - largestSpillArea.start.col + 1) *\n            (largestRows - largestSpillArea.start.row + 1);\n\n          if (currentSize > largestSize) {\n            largestSpillArea = spillArea;\n          }\n        }\n      }\n    }\n\n    // Extract values from arguments (using origin values for arrays)\n    const rowsResult = argResults[0];\n    if (!rowsResult) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Missing rows argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    let rowsValue: number | \"infinity\" = 0;\n    let isRowsInfinite = false;\n\n    if (\n      rowsResult.type === \"awaiting-evaluation\" ||\n      rowsResult.type === \"error\"\n    ) {\n      return rowsResult;\n    }\n\n    if (rowsResult.type === \"spilled-values\") {\n      throw new Error(\"Sequences cannot contain spilled values\");\n    } else if (rowsResult.type === \"value\") {\n      if (rowsResult.result.type === \"infinity\") {\n        rowsValue = \"infinity\";\n        isRowsInfinite = true;\n      } else if (rowsResult.result.type === \"number\") {\n        rowsValue = rowsResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Rows argument must be a number or INFINITY\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    const rows = isRowsInfinite ? Infinity : Math.floor(rowsValue as number);\n    if (!isRowsInfinite && rows < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Rows must be greater than 0\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate columns argument (optional, default: 1)\n    let columns = 1;\n    let isColumnsInfinite = false;\n    if (node.args.length > 1) {\n      const columnsResult = argResults[1];\n      if (!columnsResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing columns argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (columnsResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (columnsResult.type === \"value\") {\n        if (columnsResult.result.type === \"infinity\") {\n          columns = Infinity;\n          isColumnsInfinite = true;\n        } else if (columnsResult.result.type === \"number\") {\n          columns = Math.floor(columnsResult.result.value);\n        } else {\n          return {\n            type: \"error\",\n            err: FormulaError.VALUE,\n            message: \"Columns argument must be a number or INFINITY\",\n            errAddress: context.dependencyNode,\n          };\n        }\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Columns argument must be a number or INFINITY\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (!isColumnsInfinite && columns < 1) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Columns must be greater than 0\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Evaluate start argument (optional, default: 1)\n    let start = 1;\n    if (node.args.length > 2) {\n      const startResult = argResults[2];\n      if (!startResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing start argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (startResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (\n        startResult.type === \"value\" &&\n        startResult.result.type === \"number\"\n      ) {\n        start = startResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Start argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Evaluate step argument (optional, default: 1)\n    let step = 1;\n    if (node.args.length > 3) {\n      const stepResult = argResults[3];\n      if (!stepResult) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Missing step argument\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (stepResult.type === \"spilled-values\") {\n        throw new Error(\"Sequences cannot contain spilled values\");\n      } else if (\n        stepResult.type === \"value\" &&\n        stepResult.result.type === \"number\"\n      ) {\n        step = stepResult.result.value;\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Step argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // Create the spill area - if there are array inputs, use the largest input spill area\n    // Otherwise, create a new spill area based on the SEQUENCE dimensions\n    const spillArea = (origin: CellAddress): SpreadsheetRange => {\n      return hasArrayInput && largestSpillArea\n        ? largestSpillArea\n        : {\n            start: {\n              col: origin.colIndex,\n              row: origin.rowIndex,\n            },\n            end: {\n              col: isColumnsInfinite\n                ? { type: \"infinity\", sign: \"positive\" }\n                : { type: \"number\", value: origin.colIndex + columns - 1 },\n              row: isRowsInfinite\n                ? { type: \"infinity\", sign: \"positive\" }\n                : { type: \"number\", value: origin.rowIndex + rows - 1 },\n            },\n          };\n    };\n\n    // Calculate the origin result (top-left cell value)\n    const originResult: CellNumber = {\n      type: \"number\",\n      value: start,\n    };\n\n    if (isRangeOneCell(spillArea(context.cellAddress))) {\n      return {\n        type: \"value\",\n        result: originResult,\n      };\n    }\n\n    return {\n      type: \"spilled-values\",\n      spillArea,\n      source: \"SEQUENCE function\",\n      evaluate: (spillOffset, context) => {\n        if (hasArrayInput) {\n          // When we have array inputs, all cells in the broadcast area get the same SEQUENCE result\n          // The SEQUENCE is calculated once using the origin values from the input arrays\n\n          // For broadcasting, we always return the same sequence across all spilled cells\n          // Calculate the value for the origin cell of the SEQUENCE (always (0,0))\n          const x = 0;\n          const y = 0;\n\n          // Check if the origin cell is within our intended SEQUENCE area\n          if (\n            (!isColumnsInfinite && x >= columns) ||\n            (!isRowsInfinite && y >= rows)\n          ) {\n            return {\n              type: \"error\",\n              err: FormulaError.ERROR,\n              message: \"Error evaluating SEQUENCE\",\n              errAddress: context.dependencyNode,\n            };\n          }\n\n          // Calculate the sequential value for origin cell\n          // Since this is for broadcasting, we always use the origin (0,0) value\n          const sequenceIndex = 0;\n          const value = start + sequenceIndex * step;\n\n          return {\n            type: \"value\",\n            result: {\n              type: \"number\",\n              value,\n            },\n          };\n        } else {\n          // Normal SEQUENCE behavior - calculate the value for this spilled cell based on its offset\n          const x = spillOffset.x;\n          const y = spillOffset.y;\n\n          // Check if the spilled cell is within our intended area\n          if (\n            (!isColumnsInfinite && x >= columns) ||\n            (!isRowsInfinite && y >= rows)\n          ) {\n            return {\n              type: \"error\",\n              err: FormulaError.ERROR,\n              message: \"Error evaluating SEQUENCE\",\n              errAddress: context.dependencyNode,\n            };\n          }\n\n          // Calculate the sequential value\n          // Values are filled row by row: (0,0), (0,1), (0,2), ..., (1,0), (1,1), etc.\n          let sequenceIndex: number;\n          if (isColumnsInfinite && isRowsInfinite) {\n            // For infinite 2D sequences, we can't calculate a single index\n            // We'll use a simple pattern based on position\n            sequenceIndex = y + x;\n          } else if (isColumnsInfinite) {\n            // For infinite columns, sequence goes horizontally\n            sequenceIndex = x;\n          } else if (isRowsInfinite) {\n            // For infinite rows, sequence goes vertically\n            sequenceIndex = y;\n          } else {\n            // Finite dimensions - normal calculation\n            sequenceIndex = y * columns + x;\n          }\n\n          const value = start + sequenceIndex * step;\n\n          return {\n            type: \"value\",\n            result: {\n              type: \"number\",\n              value,\n            },\n          };\n        }\n      },\n      evaluateAllCells: function ({ evaluate, intersection, context, origin }) {\n        const results: CellInRangeResult[] = [];\n        let range = spillArea(origin);\n        if (intersection) {\n          const newRange = getRangeIntersection(range, intersection);\n          if (!newRange) {\n            throw new Error(\"Intersection is not valid #2\");\n          }\n          range = newRange;\n        }\n        if (\n          range.end.row.type === \"infinity\" ||\n          range.end.col.type === \"infinity\"\n        ) {\n          throw new EvaluationError(\n            FormulaError.REF,\n            `Can not evaluate all cells over an infinite range`\n          );\n        }\n\n        for (let i = range.start.row; i <= range.end.row.value; i++) {\n          for (let j = range.start.col; j <= range.end.col.value; j++) {\n            const offsetLeft = j - origin.colIndex;\n            const offsetTop = i - origin.rowIndex;\n\n            const evaled = evaluate({ x: offsetLeft, y: offsetTop }, context);\n            const relativePos = { x: offsetLeft, y: offsetTop };\n            results.push({ result: evaled, relativePos });\n          }\n        }\n\n        return { type: \"values\", values: results };\n      },\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "7DF7E0198FCF2C6364756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/criteria-parser.cjs

@@ -0,0 +1,217 @@
+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/criteria-parser.ts
+var exports_criteria_parser = {};
+__export(exports_criteria_parser, {
+  parseCriteria: () => parseCriteria,
+  matchesParsedCriteria: () => matchesParsedCriteria
+});
+module.exports = __toCommonJS(exports_criteria_parser);
+function wildcardToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexPattern = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`);
+}
+function parseSimpleValue(valueStr) {
+  const trimmed = valueStr.trim();
+  const upperTrimmed = trimmed.toUpperCase();
+  if (upperTrimmed === "TRUE") {
+    return { type: "boolean", value: true };
+  }
+  if (upperTrimmed === "FALSE") {
+    return { type: "boolean", value: false };
+  }
+  if (upperTrimmed === "INFINITY") {
+    return { type: "infinity", sign: "positive" };
+  }
+  if (upperTrimmed === "-INFINITY") {
+    return { type: "infinity", sign: "negative" };
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = Number(trimmed);
+    if (!isNaN(num) && isFinite(num)) {
+      return { type: "number", value: num };
+    }
+  }
+  return { type: "string", value: valueStr };
+}
+function parseCriteria(criteria) {
+  if (criteria.type !== "string") {
+    return { type: "exact", value: criteria };
+  }
+  const criteriaStr = criteria.value;
+  if (criteriaStr === "") {
+    return { type: "exact", value: criteria };
+  }
+  if (criteriaStr === "=") {
+    return { type: "exact", value: { type: "string", value: "" } };
+  }
+  const comparisonMatch = criteriaStr.match(/^(>=|<=|<>|>|<)(.*)$/);
+  if (comparisonMatch) {
+    const operator = comparisonMatch[1];
+    const valueStr = comparisonMatch[2];
+    if (!operator || valueStr === undefined) {
+      return { type: "error", message: "Invalid comparison operator format" };
+    }
+    if (operator === "<>" && valueStr === "") {
+      return {
+        type: "comparison",
+        operator: "<>",
+        value: { type: "string", value: "" }
+      };
+    }
+    const parsedValue2 = parseSimpleValue(valueStr);
+    return {
+      type: "comparison",
+      operator,
+      value: parsedValue2
+    };
+  }
+  if (criteriaStr.includes("*") || criteriaStr.includes("?")) {
+    return { type: "wildcard", pattern: criteriaStr };
+  }
+  const parsedValue = parseSimpleValue(criteriaStr);
+  return { type: "exact", value: parsedValue };
+}
+function matchesParsedCriteria(cellValue, parsedCriteria) {
+  switch (parsedCriteria.type) {
+    case "error":
+      return false;
+    case "exact":
+      if (cellValue.type !== parsedCriteria.value.type) {
+        return false;
+      }
+      if ("value" in cellValue && "value" in parsedCriteria.value) {
+        if (cellValue.type === "string" && parsedCriteria.value.type === "string") {
+          return cellValue.value.toLowerCase() === parsedCriteria.value.value.toLowerCase();
+        }
+        return cellValue.value === parsedCriteria.value.value;
+      }
+      if (cellValue.type === "infinity" && parsedCriteria.value.type === "infinity") {
+        return cellValue.sign === parsedCriteria.value.sign;
+      }
+      return false;
+    case "comparison":
+      if (parsedCriteria.operator === "<>" && parsedCriteria.value.type === "string" && parsedCriteria.value.value === "") {
+        return cellValue.type !== "string" || cellValue.value !== "";
+      }
+      if (parsedCriteria.operator === "<>") {
+        if (cellValue.type !== parsedCriteria.value.type) {
+          return true;
+        }
+        if ("value" in cellValue && "value" in parsedCriteria.value) {
+          return cellValue.value !== parsedCriteria.value.value;
+        }
+        if (cellValue.type === "infinity" && parsedCriteria.value.type === "infinity") {
+          return cellValue.sign !== parsedCriteria.value.sign;
+        }
+        return true;
+      }
+      if (cellValue.type !== "number" && cellValue.type !== "infinity") {
+        return false;
+      }
+      if (parsedCriteria.value.type !== "number" && parsedCriteria.value.type !== "infinity") {
+        return false;
+      }
+      if (parsedCriteria.value.type === "infinity") {
+        const criteriaSign = parsedCriteria.value.sign;
+        if (cellValue.type === "infinity") {
+          const cellSign = cellValue.sign;
+          switch (parsedCriteria.operator) {
+            case ">":
+              return cellSign === "positive" && criteriaSign === "negative";
+            case "<":
+              return cellSign === "negative" && criteriaSign === "positive";
+            case ">=":
+              return cellSign === "positive" || cellSign === criteriaSign;
+            case "<=":
+              return cellSign === "negative" || cellSign === criteriaSign;
+            default:
+              return false;
+          }
+        }
+        if (cellValue.type === "number") {
+          switch (parsedCriteria.operator) {
+            case ">":
+              return criteriaSign === "negative";
+            case "<":
+              return criteriaSign === "positive";
+            case ">=":
+              return criteriaSign === "negative";
+            case "<=":
+              return criteriaSign === "positive";
+            default:
+              return false;
+          }
+        }
+      }
+      if (parsedCriteria.value.type === "number") {
+        const criteriaNum = parsedCriteria.value.value;
+        if (cellValue.type === "infinity") {
+          switch (parsedCriteria.operator) {
+            case ">":
+              return cellValue.sign === "positive";
+            case "<":
+              return cellValue.sign === "negative";
+            case ">=":
+              return cellValue.sign === "positive";
+            case "<=":
+              return cellValue.sign === "negative";
+            default:
+              return false;
+          }
+        }
+        if (cellValue.type === "number") {
+          switch (parsedCriteria.operator) {
+            case ">":
+              return cellValue.value > criteriaNum;
+            case "<":
+              return cellValue.value < criteriaNum;
+            case ">=":
+              return cellValue.value >= criteriaNum;
+            case "<=":
+              return cellValue.value <= criteriaNum;
+            default:
+              return false;
+          }
+        }
+      }
+      return false;
+    case "wildcard":
+      if (cellValue.type !== "string") {
+        return false;
+      }
+      const regex = wildcardToRegex(parsedCriteria.pattern);
+      return regex.test(cellValue.value);
+    default:
+      return false;
+  }
+}
+
+//# debugId=031BC6604992B51864756E2164756E21

package/dist/cjs/functions/criteria-parser.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/criteria-parser.ts"],
+  "sourcesContent": [
+    "import { FormulaError, type CellValue } from \"src/core/types\";\n\n/**\n * Parsed criteria result\n */\nexport type ParsedCriteria = \n  | { type: \"exact\"; value: CellValue }\n  | { type: \"comparison\"; operator: \">\" | \"<\" | \">=\" | \"<=\" | \"<>\"; value: CellValue }\n  | { type: \"wildcard\"; pattern: string }\n  | { type: \"error\"; message: string };\n\n/**\n * Convert wildcard pattern to regex\n */\nfunction wildcardToRegex(pattern: string): RegExp {\n  // Escape regex special characters except * and ?\n  const escaped = pattern.replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$&\");\n  // Convert wildcards: * -> .*, ? -> .\n  const regexPattern = escaped.replace(/\\*/g, \".*\").replace(/\\?/g, \".\");\n  return new RegExp(`^${regexPattern}$`);\n}\n\n/**\n * Parse a simple value string to determine its type\n * This is a lightweight alternative to parseFormula for criteria strings\n */\nfunction parseSimpleValue(valueStr: string): CellValue {\n  // Trim the value\n  const trimmed = valueStr.trim();\n  \n  // Check for boolean values (case-insensitive)\n  const upperTrimmed = trimmed.toUpperCase();\n  if (upperTrimmed === \"TRUE\") {\n    return { type: \"boolean\", value: true };\n  }\n  if (upperTrimmed === \"FALSE\") {\n    return { type: \"boolean\", value: false };\n  }\n  \n  // Check for infinity values (case-insensitive)\n  if (upperTrimmed === \"INFINITY\") {\n    return { type: \"infinity\", sign: \"positive\" };\n  }\n  if (upperTrimmed === \"-INFINITY\") {\n    return { type: \"infinity\", sign: \"negative\" };\n  }\n  \n  // Check for numeric values\n  // Match: optional negative sign, digits, optional decimal point and more digits\n  // Examples: \"10\", \"-20\", \"3.14\", \"-0.5\", \"0\"\n  if (/^-?\\d+(\\.\\d+)?$/.test(trimmed)) {\n    const num = Number(trimmed);\n    if (!isNaN(num) && isFinite(num)) {\n      return { type: \"number\", value: num };\n    }\n  }\n  \n  // Default to string\n  return { type: \"string\", value: valueStr };\n}\n\n/**\n * Simple criteria parser for COUNTIF\n * Handles: exact values, comparisons (>5, <=10, <>0), and wildcards (*app, ?at)\n */\nexport function parseCriteria(criteria: CellValue): ParsedCriteria {\n  // Only string criteria can contain operators or wildcards\n  if (criteria.type !== \"string\") {\n    return { type: \"exact\", value: criteria };\n  }\n\n  const criteriaStr = criteria.value;\n\n  // Handle empty string as exact match\n  if (criteriaStr === \"\") {\n    return { type: \"exact\", value: criteria };\n  }\n\n  // Special case: \"=\" means count empty cells\n  if (criteriaStr === \"=\") {\n    return { type: \"exact\", value: { type: \"string\", value: \"\" } };\n  }\n\n  // Check for comparison operators (must be at the beginning)\n  const comparisonMatch = criteriaStr.match(/^(>=|<=|<>|>|<)(.*)$/);\n  if (comparisonMatch) {\n    const operator = comparisonMatch[1];\n    const valueStr = comparisonMatch[2];\n    \n    if (!operator || valueStr === undefined) {\n      return { type: \"error\", message: \"Invalid comparison operator format\" };\n    }\n    \n    // Special case: \"<>\" with no value means \"not empty\"\n    if (operator === \"<>\" && valueStr === \"\") {\n      return { \n        type: \"comparison\", \n        operator: \"<>\", \n        value: { type: \"string\", value: \"\" } \n      };\n    }\n\n    // Parse the value part to get the proper type\n    const parsedValue = parseSimpleValue(valueStr);\n    return { \n      type: \"comparison\", \n      operator: operator as \">\" | \"<\" | \">=\" | \"<=\" | \"<>\", \n      value: parsedValue\n    };\n  }\n\n  // Check for wildcards\n  if (criteriaStr.includes(\"*\") || criteriaStr.includes(\"?\")) {\n    return { type: \"wildcard\", pattern: criteriaStr };\n  }\n\n  // Parse as a simple value to get the proper type\n  const parsedValue = parseSimpleValue(criteriaStr);\n  return { type: \"exact\", value: parsedValue };\n}\n\n/**\n * Check if a cell value matches the parsed criteria\n */\nexport function matchesParsedCriteria(cellValue: CellValue, parsedCriteria: ParsedCriteria): boolean {\n  switch (parsedCriteria.type) {\n    case \"error\":\n      return false;\n\n    case \"exact\":\n      // Exact match - must be same type and value\n      if (cellValue.type !== parsedCriteria.value.type) {\n        return false;\n      }\n      if (\"value\" in cellValue && \"value\" in parsedCriteria.value) {\n        if (cellValue.type === 'string' && parsedCriteria.value.type === 'string') {\n          return cellValue.value.toLowerCase() === parsedCriteria.value.value.toLowerCase();\n        }\n        return cellValue.value === parsedCriteria.value.value;\n      }\n      if (cellValue.type === \"infinity\" && parsedCriteria.value.type === \"infinity\") {\n        return cellValue.sign === parsedCriteria.value.sign;\n      }\n      return false;\n\n    case \"comparison\":\n      // Special case: \"<>\" with empty string means \"not empty\"\n      if (parsedCriteria.operator === \"<>\" && \n          parsedCriteria.value.type === \"string\" && \n          parsedCriteria.value.value === \"\") {\n        return cellValue.type !== \"string\" || cellValue.value !== \"\";\n      }\n\n      // For other comparisons, handle by operator\n      if (parsedCriteria.operator === \"<>\") {\n        // Not equals - same logic as exact but negated\n        if (cellValue.type !== parsedCriteria.value.type) {\n          return true; // Different types are not equal\n        }\n        if (\"value\" in cellValue && \"value\" in parsedCriteria.value) {\n          return cellValue.value !== parsedCriteria.value.value;\n        }\n        if (cellValue.type === \"infinity\" && parsedCriteria.value.type === \"infinity\") {\n          return cellValue.sign !== parsedCriteria.value.sign;\n        }\n        return true;\n      }\n\n      // Numeric comparison operators - only work with numbers and infinity\n      if (cellValue.type !== \"number\" && cellValue.type !== \"infinity\") {\n        return false;\n      }\n      if (parsedCriteria.value.type !== \"number\" && parsedCriteria.value.type !== \"infinity\") {\n        return false; // Can only compare with numeric or infinity criteria\n      }\n\n      // Handle when criteria is infinity\n      if (parsedCriteria.value.type === \"infinity\") {\n        const criteriaSign = parsedCriteria.value.sign;\n        \n        // Handle when cell value is also infinity\n        if (cellValue.type === \"infinity\") {\n          const cellSign = cellValue.sign;\n          switch (parsedCriteria.operator) {\n            case \">\":\n              // +∞ > -∞, but not +∞ > +∞\n              return cellSign === \"positive\" && criteriaSign === \"negative\";\n            case \"<\":\n              // -∞ < +∞, but not -∞ < -∞\n              return cellSign === \"negative\" && criteriaSign === \"positive\";\n            case \">=\":\n              // +∞ >= +∞, +∞ >= -∞, but not -∞ >= +∞\n              return cellSign === \"positive\" || (cellSign === criteriaSign);\n            case \"<=\":\n              // -∞ <= -∞, -∞ <= +∞, but not +∞ <= -∞\n              return cellSign === \"negative\" || (cellSign === criteriaSign);\n            default:\n              return false;\n          }\n        }\n        \n        // Handle when cell value is a finite number\n        if (cellValue.type === \"number\") {\n          switch (parsedCriteria.operator) {\n            case \">\":\n              // No finite number is > +∞, all finite numbers > -∞\n              return criteriaSign === \"negative\";\n            case \"<\":\n              // All finite numbers < +∞, no finite number < -∞\n              return criteriaSign === \"positive\";\n            case \">=\":\n              // No finite number >= +∞, all finite numbers >= -∞\n              return criteriaSign === \"negative\";\n            case \"<=\":\n              // All finite numbers <= +∞, no finite number <= -∞\n              return criteriaSign === \"positive\";\n            default:\n              return false;\n          }\n        }\n      }\n\n      // Handle when criteria is a number (not infinity)\n      if (parsedCriteria.value.type === \"number\") {\n        const criteriaNum = parsedCriteria.value.value;\n\n        // Handle infinity cell values with numeric criteria\n        if (cellValue.type === \"infinity\") {\n          switch (parsedCriteria.operator) {\n            case \">\":\n              return cellValue.sign === \"positive\"; // +∞ > any number\n            case \"<\":\n              return cellValue.sign === \"negative\"; // -∞ < any number\n            case \">=\":\n              return cellValue.sign === \"positive\"; // +∞ >= any number\n            case \"<=\":\n              return cellValue.sign === \"negative\"; // -∞ <= any number\n            default:\n              return false;\n          }\n        }\n\n        // Regular number comparison\n        if (cellValue.type === \"number\") {\n          switch (parsedCriteria.operator) {\n            case \">\":\n              return cellValue.value > criteriaNum;\n            case \"<\":\n              return cellValue.value < criteriaNum;\n            case \">=\":\n              return cellValue.value >= criteriaNum;\n            case \"<=\":\n              return cellValue.value <= criteriaNum;\n            default:\n              return false;\n          }\n        }\n      }\n      \n      return false;\n\n    case \"wildcard\":\n      // Wildcard matching - only works with strings\n      if (cellValue.type !== \"string\") {\n        return false;\n      }\n      const regex = wildcardToRegex(parsedCriteria.pattern);\n      return regex.test(cellValue.value);\n\n    default:\n      return false;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "031BC6604992B51864756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/criteria-utils.cjs

@@ -0,0 +1,291 @@
+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/criteria-utils.ts
+var exports_criteria_utils = {};
+__export(exports_criteria_utils, {
+  validateSingleCriteriaArgs: () => validateSingleCriteriaArgs,
+  validateMultiCriteriaArgs: () => validateMultiCriteriaArgs,
+  validateCountifsArgs: () => validateCountifsArgs,
+  processMultiCriteriaValues: () => processMultiCriteriaValues,
+  parseCriteriaPairs: () => parseCriteriaPairs,
+  hasEmptyCriteria: () => hasEmptyCriteria
+});
+module.exports = __toCommonJS(exports_criteria_utils);
+var import_types = require("src/core/types");
+var import_criteria_parser = require("./criteria-parser.cjs");
+var import_utils = require("src/core/utils");
+var import_evaluation_error = require("src/evaluator/evaluation-error");
+function parseCriteriaPairs(node, context, evaluateNode, startIndex = 1) {
+  const criteriaPairs = [];
+  for (let i = startIndex;i < node.args.length; i += 2) {
+    const criteriaRangeResult = evaluateNode.call(this, node.args[i], context);
+    if (criteriaRangeResult.type === "error" || criteriaRangeResult.type === "awaiting-evaluation") {
+      return criteriaRangeResult;
+    }
+    const criteriaResult = evaluateNode.call(this, node.args[i + 1], context);
+    if (criteriaResult.type === "error" || criteriaResult.type === "awaiting-evaluation") {
+      return criteriaResult;
+    }
+    let result;
+    if (criteriaResult.type === "spilled-values") {
+      const firstSpilledValue = criteriaResult.evaluate({ x: 0, y: 0 }, context);
+      if (firstSpilledValue.type === "error" || firstSpilledValue.type === "awaiting-evaluation") {
+        return firstSpilledValue;
+      } else {
+        result = firstSpilledValue;
+      }
+    } else {
+      result = criteriaResult;
+    }
+    const parsedCriteria = import_criteria_parser.parseCriteria(result.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: parsedCriteria.message,
+        errAddress: context.dependencyNode
+      };
+    }
+    criteriaPairs.push({
+      rangeResult: criteriaRangeResult,
+      parsedCriteria
+    });
+  }
+  return criteriaPairs;
+}
+function hasEmptyCriteria(criteriaPairs) {
+  return criteriaPairs.some(({ parsedCriteria }) => parsedCriteria.type === "exact" && parsedCriteria.value.type === "string" && parsedCriteria.value.value === "");
+}
+function processMultiCriteriaValues(evaluator, valueRangeResult, criteriaPairs, context, lookupOrder) {
+  const results = [];
+  const criteriaPairWithError = criteriaPairs.map((pair) => pair.rangeResult).find((result) => result.type === "error" || result.type === "awaiting-evaluation");
+  if (criteriaPairWithError) {
+    return criteriaPairWithError;
+  }
+  if (hasEmptyCriteria(criteriaPairs) && valueRangeResult.type === "spilled-values") {
+    return handleEmptyCriteriaSpilledValues(valueRangeResult, criteriaPairs, context);
+  }
+  if (valueRangeResult.type === "value") {
+    let allMatch = true;
+    for (const { rangeResult, parsedCriteria } of criteriaPairs) {
+      if (rangeResult.type === "value") {
+        if (!import_criteria_parser.matchesParsedCriteria(rangeResult.result, parsedCriteria)) {
+          allMatch = false;
+          break;
+        }
+      } else {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      results.push(valueRangeResult);
+    }
+  } else if (valueRangeResult.type === "spilled-values") {
+    const valueSpillArea = valueRangeResult.spillArea(context.cellAddress);
+    for (const { rangeResult } of criteriaPairs) {
+      if (rangeResult.type === "spilled-values") {
+        const criteriaSpillArea = rangeResult.spillArea(context.cellAddress);
+        const valueRelRange = import_utils.getRelativeRange(valueSpillArea, context.cellAddress);
+        const criteriaRelRange = import_utils.getRelativeRange(criteriaSpillArea, context.cellAddress);
+        const widthsMatch = valueRelRange.width.type === "infinity" && criteriaRelRange.width.type === "infinity" || valueRelRange.width.type === "number" && criteriaRelRange.width.type === "number" && valueRelRange.width.value === criteriaRelRange.width.value;
+        const heightsMatch = valueRelRange.height.type === "infinity" && criteriaRelRange.height.type === "infinity" || valueRelRange.height.type === "number" && criteriaRelRange.height.type === "number" && valueRelRange.height.value === criteriaRelRange.height.value;
+        if (!widthsMatch || !heightsMatch) {
+          throw new import_evaluation_error.EvaluationError(import_types.FormulaError.VALUE, "Criteria range dimensions do not match value range dimensions");
+        }
+      }
+    }
+    const valueResults = valueRangeResult.evaluateAllCells.call(evaluator, {
+      context,
+      evaluate: valueRangeResult.evaluate,
+      origin: context.cellAddress,
+      lookupOrder
+    });
+    const criteriaResultsArrays = criteriaPairs.map(({ rangeResult }) => {
+      if (rangeResult.type === "spilled-values") {
+        const criteriaResults = rangeResult.evaluateAllCells.call(evaluator, {
+          context,
+          evaluate: rangeResult.evaluate,
+          origin: context.cellAddress,
+          lookupOrder
+        });
+        return { type: "array", results: criteriaResults };
+      } else {
+        return { type: "single", value: rangeResult };
+      }
+    });
+    const criteriaMaps = criteriaResultsArrays.map((criteriaData) => {
+      if (criteriaData.type === "single") {
+        return null;
+      }
+      if (criteriaData.results.type !== "values") {
+        return null;
+      }
+      const map = new Map;
+      for (const { result, relativePos } of criteriaData.results.values) {
+        const key = `${relativePos.x},${relativePos.y}`;
+        map.set(key, result);
+      }
+      return map;
+    });
+    if (valueResults.type !== "values") {
+      return valueResults;
+    }
+    for (const valueCell of valueResults.values) {
+      if (!valueCell) {
+        continue;
+      }
+      const posKey = `${valueCell.relativePos.x},${valueCell.relativePos.y}`;
+      let allMatch = true;
+      for (let j = 0;j < criteriaPairs.length; j++) {
+        let criteriaCell;
+        if (criteriaResultsArrays[j].type === "single") {
+          criteriaCell = criteriaResultsArrays[j].value;
+        } else {
+          criteriaCell = criteriaMaps[j]?.get(posKey);
+        }
+        if (!criteriaCell) {
+          const parsedCriteria = criteriaPairs[j].parsedCriteria;
+          const emptyValue = { type: "string", value: "" };
+          if (!import_criteria_parser.matchesParsedCriteria(emptyValue, parsedCriteria)) {
+            allMatch = false;
+            break;
+          }
+        } else if (criteriaCell.type === "error") {
+          allMatch = false;
+          break;
+        } else if (criteriaCell.type === "value") {
+          if (!import_criteria_parser.matchesParsedCriteria(criteriaCell.result, criteriaPairs[j].parsedCriteria)) {
+            allMatch = false;
+            break;
+          }
+        } else if (criteriaCell.type === "awaiting-evaluation") {
+          return criteriaCell;
+        } else {
+          allMatch = false;
+          break;
+        }
+      }
+      if (allMatch) {
+        results.push(valueCell.result);
+      }
+    }
+  }
+  return { type: "values", values: results };
+}
+function validateMultiCriteriaArgs(functionName, argCount, context) {
+  if (argCount < 3 || (argCount - 1) % 2 !== 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `${functionName} function requires an odd number of arguments (min 3): value_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...`,
+      errAddress: context.dependencyNode
+    };
+  }
+  return null;
+}
+function validateCountifsArgs(argCount, context) {
+  if (argCount < 2 || argCount % 2 !== 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "COUNTIFS function requires an even number of arguments (min 2): criteria_range1, criteria1, [criteria_range2, criteria2], ...",
+      errAddress: context.dependencyNode
+    };
+  }
+  return null;
+}
+function validateSingleCriteriaArgs(functionName, argCount, context) {
+  if (argCount < 2 || argCount > 3) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `${functionName} function takes 2 or 3 arguments`,
+      errAddress: context.dependencyNode
+    };
+  }
+  return null;
+}
+function handleEmptyCriteriaSpilledValues(valueRangeResult, criteriaPairs, context) {
+  if (!hasEmptyCriteria(criteriaPairs) || valueRangeResult.type !== "spilled-values") {
+    throw new Error("Not an empty criteria case");
+  }
+  const results = [];
+  const valueSpillArea = valueRangeResult.spillArea(context.cellAddress);
+  if (valueSpillArea.end.col.type === "infinity" || valueSpillArea.end.row.type === "infinity") {
+    throw new import_evaluation_error.EvaluationError(import_types.FormulaError.VALUE, "Can not process infinite ranges with empty cell criteria");
+  }
+  if (valueSpillArea.end.col.type === "number" && valueSpillArea.end.row.type === "number") {
+    for (let row = valueSpillArea.start.row;row <= valueSpillArea.end.row.value; row++) {
+      for (let col = valueSpillArea.start.col;col <= valueSpillArea.end.col.value; col++) {
+        const valueCell = valueRangeResult.evaluate({
+          x: col - valueSpillArea.start.col,
+          y: row - valueSpillArea.start.row
+        }, context);
+        let allMatch = true;
+        for (const { rangeResult, parsedCriteria } of criteriaPairs) {
+          let criteriaCell;
+          if (rangeResult.type === "spilled-values") {
+            const criteriaSpillArea = rangeResult.spillArea(context.cellAddress);
+            const criteriaRow = row - valueSpillArea.start.row + criteriaSpillArea.start.row;
+            const criteriaCol = col - valueSpillArea.start.col + criteriaSpillArea.start.col;
+            if (criteriaRow <= (criteriaSpillArea.end.row.type === "number" ? criteriaSpillArea.end.row.value : Infinity) && criteriaCol <= (criteriaSpillArea.end.col.type === "number" ? criteriaSpillArea.end.col.value : Infinity)) {
+              criteriaCell = rangeResult.evaluate({
+                x: criteriaCol - criteriaSpillArea.start.col,
+                y: criteriaRow - criteriaSpillArea.start.row
+              }, context);
+            }
+          } else if (rangeResult.type === "value") {
+            criteriaCell = rangeResult;
+          }
+          const isEmptyCriteria = parsedCriteria.type === "exact" && parsedCriteria.value.type === "string" && parsedCriteria.value.value === "" || parsedCriteria.type === "comparison" && parsedCriteria.operator === "<>" && parsedCriteria.value.type === "string" && parsedCriteria.value.value === "";
+          if (isEmptyCriteria) {
+            const isEmpty = !criteriaCell || criteriaCell.type === "value" && criteriaCell.result.type === "string" && criteriaCell.result.value === "";
+            const shouldMatch = parsedCriteria.type === "exact" ? isEmpty : !isEmpty;
+            if (!shouldMatch) {
+              allMatch = false;
+              break;
+            }
+          } else {
+            if (!criteriaCell || criteriaCell.type !== "value" || !import_criteria_parser.matchesParsedCriteria(criteriaCell.result, parsedCriteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+        }
+        if (allMatch && valueCell) {
+          results.push(valueCell);
+        }
+      }
+    }
+  }
+  return { type: "values", values: results };
+}
+
+//# debugId=5ACCD9DEBF70FD2764756E2164756E21