@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/information/column/column.cjs

@@ -0,0 +1,144 @@
+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/information/column/column.ts
+var exports_column = {};
+__export(exports_column, {
+  COLUMN: () => COLUMN
+});
+module.exports = __toCommonJS(exports_column);
+var import_types = require("src/core/types");
+var import_evaluation_error = require("src/evaluator/evaluation-error");
+var import_utils = require("src/core/utils");
+var COLUMN = {
+  name: "COLUMN",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      context.addContextDependency("col");
+      return {
+        type: "value",
+        result: { type: "number", value: context.cellAddress.colIndex + 1 }
+      };
+    }
+    if (node.args.length > 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "COLUMN function takes at most 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const argNode = node.args[0];
+    const argResult = this.evaluateNode(argNode, context);
+    if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+      return argResult;
+    }
+    const cellOrRange = argResult.type === "spilled-values" ? argResult.sourceCell ?? argResult.sourceRange : argResult.sourceCell;
+    if (!cellOrRange) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "COLUMN function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (import_utils.isCellAddress(cellOrRange)) {
+      return {
+        type: "value",
+        result: { type: "number", value: cellOrRange.colIndex + 1 }
+      };
+    }
+    if (import_utils.isRangeAddress(cellOrRange) && argResult.type === "spilled-values") {
+      const sourceRange = cellOrRange.range;
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => argResult.spillArea(origin),
+        sourceRange: cellOrRange,
+        source: "COLUMN with range/array argument",
+        evaluate: (spillOffset, evalContext) => {
+          if (sourceRange) {
+            const actualCol2 = sourceRange.start.col + spillOffset.x;
+            return {
+              type: "value",
+              result: { type: "number", value: actualCol2 + 1 }
+            };
+          }
+          const spillArea = argResult.spillArea(evalContext.cellAddress);
+          const actualCol = spillArea.start.col + spillOffset.x;
+          return {
+            type: "value",
+            result: { type: "number", value: actualCol + 1 }
+          };
+        },
+        evaluateAllCells: ({ evaluate, intersection, context: context2, origin }) => {
+          let rangeToEvaluate = cellOrRange.range;
+          if (intersection) {
+            const newRange = import_utils.getRangeIntersection(rangeToEvaluate, intersection);
+            if (!newRange) {
+              return {
+                type: "error",
+                err: import_types.FormulaError.VALUE,
+                message: "Invalid intersection range for COLUMN function",
+                errAddress: context2.dependencyNode
+              };
+            }
+            rangeToEvaluate = newRange;
+          }
+          if (rangeToEvaluate.end.row.type === "infinity" || rangeToEvaluate.end.col.type === "infinity") {
+            throw new import_evaluation_error.EvaluationError(import_types.FormulaError.VALUE, "COLUMN function cannot evaluate all cells over an infinite range");
+          }
+          const startCol = rangeToEvaluate.start.col;
+          const endCol = rangeToEvaluate.end.col.value;
+          const colSet = new Set;
+          for (let col = startCol;col <= endCol; col++) {
+            colSet.add(col + 1);
+          }
+          const cols = Array.from(colSet).sort((a, b) => a - b);
+          const results = [];
+          for (let i = 0;i < cols.length; i++) {
+            const relativePos = { x: i, y: 0 };
+            const evaled = evaluate(relativePos, context2);
+            results.push({
+              result: evaled,
+              relativePos
+            });
+          }
+          return { type: "values", values: results };
+        }
+      };
+    }
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "COLUMN function requires a cell or range reference",
+      errAddress: context.dependencyNode
+    };
+  }
+};
+
+//# debugId=CE387FC5C24B1D2264756E2164756E21

package/dist/cjs/functions/information/column/column.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/column/column.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInRangeResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode, RangeNode } from \"src/parser/ast\";\nimport { EvaluationError } from \"src/evaluator/evaluation-error\";\nimport {\n  getRangeIntersection,\n  isCellAddress,\n  isRangeAddress,\n} from \"src/core/utils\";\n\n/**\n * COLUMN function - Returns the column number of a reference\n *\n * Usage: COLUMN([reference])\n *\n * If reference is omitted, returns the column number of the cell in which the formula appears.\n *\n * Examples:\n * - COLUMN() returns the column number of the current cell\n * - COLUMN(C5) returns 3\n * - COLUMN(A1:E1) returns an array of column numbers {1,2,3,4,5}\n */\nexport const COLUMN: FunctionDefinition = {\n  name: \"COLUMN\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // If no arguments, return the column of the current cell (1-based)\n    if (node.args.length === 0) {\n      context.addContextDependency(\"col\");\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: context.cellAddress.colIndex + 1 },\n      };\n    }\n\n    if (node.args.length > 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COLUMN function takes at most 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const argNode = node.args[0]!;\n\n    // Evaluate the argument\n    const argResult = this.evaluateNode(argNode, context);\n\n    // Handle errors and awaiting evaluation\n    if (\n      argResult.type === \"error\" ||\n      argResult.type === \"awaiting-evaluation\"\n    ) {\n      return argResult;\n    }\n\n    // Check if we have a cell or range reference\n    const cellOrRange =\n      argResult.type === \"spilled-values\"\n        ? (argResult.sourceCell ?? argResult.sourceRange)\n        : argResult.sourceCell;\n\n    // If we don't have a sourceCell or sourceRange, the argument is invalid\n    if (!cellOrRange) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COLUMN function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // If we have a sourceCell (single cell reference), return its column\n    if (isCellAddress(cellOrRange)) {\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: cellOrRange.colIndex + 1 },\n      };\n    }\n\n    // If we have a sourceRange, return spilled column numbers\n    if (isRangeAddress(cellOrRange) && argResult.type === \"spilled-values\") {\n      const sourceRange = cellOrRange.range;\n\n      // Return as spilled values - evaluate returns column numbers based on position\n      return {\n        type: \"spilled-values\",\n        spillArea: (origin) => argResult.spillArea(origin),\n        sourceRange: cellOrRange,\n        source: \"COLUMN with range/array argument\",\n        evaluate: (spillOffset, evalContext) => {\n          // If we have a sourceRange, use it to get the actual column number\n          if (sourceRange) {\n            const actualCol = sourceRange.start.col + spillOffset.x;\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: actualCol + 1 }, // 1-based\n            };\n          }\n\n          // Otherwise, use spillArea to get the column number relative to where it appears\n          const spillArea = argResult.spillArea(evalContext.cellAddress);\n          const actualCol = spillArea.start.col + spillOffset.x;\n          return {\n            type: \"value\",\n            result: { type: \"number\", value: actualCol + 1 }, // 1-based\n          };\n        },\n        evaluateAllCells: ({ evaluate, intersection, context, origin }) => {\n          // Determine the actual range to evaluate\n          let rangeToEvaluate = cellOrRange.range;\n\n          // Apply intersection if provided\n          if (intersection) {\n            // Use the intersection range\n            const newRange = getRangeIntersection(\n              rangeToEvaluate,\n              intersection\n            );\n            if (!newRange) {\n              return {\n                type: \"error\",\n                err: FormulaError.VALUE,\n                message:\n                  \"Invalid intersection range for COLUMN function\",\n                errAddress: context.dependencyNode,\n              };\n            }\n            rangeToEvaluate = newRange;\n          }\n\n          // Check if the range is infinite\n          if (\n            rangeToEvaluate.end.row.type === \"infinity\" ||\n            rangeToEvaluate.end.col.type === \"infinity\"\n          ) {\n            throw new EvaluationError(\n              FormulaError.VALUE,\n              \"COLUMN function cannot evaluate all cells over an infinite range\"\n            );\n          }\n\n          // Extract unique column numbers from the range\n          const startCol = rangeToEvaluate.start.col;\n          const endCol = rangeToEvaluate.end.col.value;\n\n          const colSet = new Set<number>();\n          for (let col = startCol; col <= endCol; col++) {\n            colSet.add(col + 1); // 1-based\n          }\n          const cols = Array.from(colSet).sort((a, b) => a - b);\n\n          const results: CellInRangeResult[] = [];\n          for (let i = 0; i < cols.length; i++) {\n            const relativePos = { x: i, y: 0 };\n            const evaled = evaluate(relativePos, context);\n            results.push({\n              result: evaled!,\n              relativePos,\n            });\n          }\n          return { type: \"values\", values: results };\n        },\n      };\n    }\n\n    // If we reach here, cellOrRange type is unknown\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"COLUMN function requires a cell or range reference\",\n      errAddress: context.dependencyNode,\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "CE387FC5C24B1D2264756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/information/row/row.cjs

@@ -0,0 +1,150 @@
+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/information/row/row.ts
+var exports_row = {};
+__export(exports_row, {
+  ROW: () => ROW
+});
+module.exports = __toCommonJS(exports_row);
+var import_types = require("src/core/types");
+var import_evaluation_error = require("src/evaluator/evaluation-error");
+var import_utils = require("src/core/utils");
+var ROW = {
+  name: "ROW",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      context.addContextDependency("row");
+      return {
+        type: "value",
+        result: {
+          type: "number",
+          value: context.cellAddress.rowIndex + 1
+        }
+      };
+    }
+    if (node.args.length > 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ROW function takes at most 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const argNode = node.args[0];
+    const argResult = this.evaluateNode(argNode, context);
+    if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+      return argResult;
+    }
+    const cellOrRange = argResult.type === "spilled-values" ? argResult.sourceCell ?? argResult.sourceRange : argResult.sourceCell;
+    if (!cellOrRange) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ROW function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (import_utils.isCellAddress(cellOrRange)) {
+      return {
+        type: "value",
+        result: { type: "number", value: cellOrRange.rowIndex + 1 }
+      };
+    }
+    if (import_utils.isRangeAddress(cellOrRange) && argResult.type === "spilled-values") {
+      const sourceRange = cellOrRange.range;
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => argResult.spillArea(origin),
+        sourceRange: cellOrRange,
+        source: "ROW with range/array argument",
+        evaluate: (spillOffset, evalContext) => {
+          if (sourceRange) {
+            const actualRow2 = sourceRange.start.row + spillOffset.y;
+            return {
+              type: "value",
+              result: { type: "number", value: actualRow2 + 1 }
+            };
+          }
+          const spillArea = argResult.spillArea(evalContext.cellAddress);
+          const actualRow = spillArea.start.row + spillOffset.y;
+          return {
+            type: "value",
+            result: { type: "number", value: actualRow + 1 }
+          };
+        },
+        evaluateAllCells: ({ evaluate, intersection, context: context2, origin }) => {
+          let rangeToEvaluate = cellOrRange.range;
+          if (intersection) {
+            const newRange = import_utils.getRangeIntersection(rangeToEvaluate, intersection);
+            if (!newRange) {
+              return {
+                type: "error",
+                err: import_types.FormulaError.VALUE,
+                message: "Intersection range is not valid",
+                errAddress: context2.dependencyNode
+              };
+            }
+            rangeToEvaluate = newRange;
+          }
+          if (rangeToEvaluate.end.row.type === "infinity" || rangeToEvaluate.end.col.type === "infinity") {
+            throw new import_evaluation_error.EvaluationError(import_types.FormulaError.VALUE, "ROW function cannot evaluate all cells over an infinite range");
+          }
+          const startRow = rangeToEvaluate.start.row;
+          const endRow = rangeToEvaluate.end.row.value;
+          const rowSet = new Set;
+          for (let row = startRow;row <= endRow; row++) {
+            rowSet.add(row + 1);
+          }
+          const rows = Array.from(rowSet).sort((a, b) => a - b);
+          const results = [];
+          for (let i = 0;i < rows.length; i++) {
+            const relativePos = { x: 0, y: i };
+            const evaled = evaluate(relativePos, context2);
+            results.push({
+              result: evaled,
+              relativePos
+            });
+          }
+          return {
+            type: "values",
+            values: results
+          };
+        }
+      };
+    }
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "ROW function requires a cell or range reference",
+      errAddress: context.dependencyNode
+    };
+  }
+};
+
+//# debugId=F401C5A2A4B1B2BE64756E2164756E21

package/dist/cjs/functions/information/row/row.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/row/row.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInRangeResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode, RangeNode } from \"src/parser/ast\";\nimport { EvaluationError } from \"src/evaluator/evaluation-error\";\nimport {\n  getRangeIntersection,\n  isCellAddress,\n  isRangeAddress,\n} from \"src/core/utils\";\n\n/**\n * ROW function - Returns the row number of a reference\n *\n * Usage: ROW([reference])\n *\n * If reference is omitted, returns the row number of the cell in which the formula appears.\n *\n * Examples:\n * - ROW() returns the row number of the current cell\n * - ROW(A5) returns 5\n * - ROW(A5:A10) returns an array of row numbers {5;6;7;8;9;10}\n */\nexport const ROW: FunctionDefinition = {\n  name: \"ROW\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // If no arguments, return the row of the current cell (1-based)\n    if (node.args.length === 0) {\n      context.addContextDependency(\"row\");\n      return {\n        type: \"value\",\n        result: {\n          type: \"number\",\n          value: context.cellAddress.rowIndex + 1,\n        },\n      };\n    }\n\n    if (node.args.length > 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ROW function takes at most 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const argNode = node.args[0]!;\n\n    // Evaluate the argument\n    const argResult = this.evaluateNode(argNode, context);\n\n    // Handle errors and awaiting evaluation\n    if (\n      argResult.type === \"error\" ||\n      argResult.type === \"awaiting-evaluation\"\n    ) {\n      return argResult;\n    }\n\n    // Check if we have a cell or range reference\n    const cellOrRange =\n      argResult.type === \"spilled-values\"\n        ? (argResult.sourceCell ?? argResult.sourceRange)\n        : argResult.sourceCell;\n\n    // If we don't have a sourceCell or sourceRange, the argument is invalid\n    if (!cellOrRange) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ROW function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // If we have a sourceCell (single cell reference), return its row\n    if (isCellAddress(cellOrRange)) {\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: cellOrRange.rowIndex + 1 },\n      };\n    }\n\n    // If we have a sourceRange, return spilled row numbers\n    if (isRangeAddress(cellOrRange) && argResult.type === \"spilled-values\") {\n      const sourceRange = cellOrRange.range;\n\n      // Return as spilled values - evaluate returns row numbers based on position\n      return {\n        type: \"spilled-values\",\n        spillArea: (origin) => argResult.spillArea(origin),\n        sourceRange: cellOrRange,\n        source: \"ROW with range/array argument\",\n        evaluate: (spillOffset, evalContext) => {\n          // If we have a sourceRange, use it to get the actual row number\n          if (sourceRange) {\n            const actualRow = sourceRange.start.row + spillOffset.y;\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: actualRow + 1 }, // 1-based\n            };\n          }\n\n          // Otherwise, use spillArea to get the row number relative to where it appears\n          const spillArea = argResult.spillArea(evalContext.cellAddress);\n          const actualRow = spillArea.start.row + spillOffset.y;\n          return {\n            type: \"value\",\n            result: { type: \"number\", value: actualRow + 1 }, // 1-based\n          };\n        },\n        evaluateAllCells: ({ evaluate, intersection, context, origin }) => {\n          // Determine the actual range to evaluate\n          let rangeToEvaluate = cellOrRange.range;\n\n          // Apply intersection if provided\n          if (intersection) {\n            // Use the intersection range\n            const newRange = getRangeIntersection(\n              rangeToEvaluate,\n              intersection\n            );\n            if (!newRange) {\n              return {\n                type: \"error\",\n                err: FormulaError.VALUE,\n                message: \"Intersection range is not valid\",\n                errAddress: context.dependencyNode,\n              };\n            }\n            rangeToEvaluate = newRange;\n          }\n\n          // Check if the range is infinite\n          if (\n            rangeToEvaluate.end.row.type === \"infinity\" ||\n            rangeToEvaluate.end.col.type === \"infinity\"\n          ) {\n            throw new EvaluationError(\n              FormulaError.VALUE,\n              \"ROW function cannot evaluate all cells over an infinite range\"\n            );\n          }\n\n          // Extract unique row numbers from the range\n          const startRow = rangeToEvaluate.start.row;\n          const endRow = rangeToEvaluate.end.row.value;\n\n          const rowSet = new Set<number>();\n          for (let row = startRow; row <= endRow; row++) {\n            rowSet.add(row + 1); // 1-based\n          }\n          const rows = Array.from(rowSet).sort((a, b) => a - b);\n\n          const results: CellInRangeResult[] = [];\n          for (let i = 0; i < rows.length; i++) {\n            const relativePos = { x: 0, y: i };\n            const evaled = evaluate(relativePos, context);\n            results.push({\n              result: evaled,\n              relativePos,\n            });\n          }\n          return {\n            type: \"values\",\n            values: results,\n          };\n        },\n      };\n    }\n\n    // If we reach here, cellOrRange type is unknown\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"ROW function requires a cell or range reference\",\n      errAddress: context.dependencyNode,\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "F401C5A2A4B1B2BE64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/logical/and/and.cjs

@@ -0,0 +1,112 @@
+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/logical/and/and.ts
+var exports_and = {};
+__export(exports_and, {
+  AND: () => AND
+});
+module.exports = __toCommonJS(exports_and);
+var import_types = require("src/core/types");
+function isTruthy(value) {
+  switch (value.type) {
+    case "boolean":
+      return value.value;
+    case "number":
+      return value.value !== 0;
+    case "string":
+      return value.value !== "";
+    case "infinity":
+      return true;
+    default:
+      return false;
+  }
+}
+var AND = {
+  name: "AND",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "AND function requires at least one argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    for (const arg of node.args) {
+      const argResult = this.evaluateNode(arg, context);
+      if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+        return argResult;
+      }
+      if (argResult.type === "value") {
+        if (!isTruthy(argResult.result)) {
+          return {
+            type: "value",
+            result: { type: "boolean", value: false }
+          };
+        }
+      } else if (argResult.type === "spilled-values") {
+        const cellValues = argResult.evaluateAllCells.call(this, {
+          context,
+          origin: context.cellAddress,
+          evaluate: argResult.evaluate,
+          lookupOrder: "col-major"
+        });
+        if (cellValues.type === "error" || cellValues.type === "awaiting-evaluation") {
+          return cellValues;
+        }
+        for (const cellValue of cellValues.values) {
+          if (cellValue.result.type === "error") {
+            return cellValue.result;
+          }
+          if (cellValue.result.type === "value") {
+            if (!isTruthy(cellValue.result.result)) {
+              return {
+                type: "value",
+                result: { type: "boolean", value: false }
+              };
+            }
+          }
+        }
+      } else {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "Invalid argument type for AND function",
+          errAddress: context.dependencyNode
+        };
+      }
+    }
+    return {
+      type: "value",
+      result: { type: "boolean", value: true }
+    };
+  }
+};
+
+//# debugId=A0E644E550D6D44364756E2164756E21

package/dist/cjs/functions/logical/and/and.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/logical/and/and.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type ErrorEvaluationResult,\n} from \"src/core/types\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * AND function - Returns TRUE if all arguments are TRUE, FALSE otherwise\n *\n * Usage: AND(logical1, [logical2], ...)\n *\n * logical1, logical2, ...: Logical values or expressions to evaluate\n *\n * Examples:\n *   AND(TRUE, TRUE) - returns TRUE\n *   AND(TRUE, FALSE) - returns FALSE\n *   AND(A1>10, B1<20) - returns TRUE if both conditions are met\n *   AND(A1:A3) - returns TRUE if all values in A1:A3 are truthy\n *\n * Note:\n * - Supports spilled values (dynamic arrays) for arguments\n * - Logical evaluation: 0 and empty string are FALSE, everything else is TRUE\n * - If any argument is spilled, returns spilled results\n * - Short-circuit evaluation: stops at first FALSE value\n */\n\n/**\n * Convert a cell value to boolean for logical evaluation\n */\nfunction isTruthy(value: CellValue): boolean {\n  switch (value.type) {\n    case \"boolean\":\n      return value.value;\n    case \"number\":\n      return value.value !== 0;\n    case \"string\":\n      return value.value !== \"\";\n    case \"infinity\":\n      return true; // Infinity is truthy\n    default:\n      return false;\n  }\n}\n\n// AND function does not create spilled results - it processes all values in ranges\n// as individual logical tests and returns a single boolean result\n\n/**\n * AND function implementation\n */\nexport const AND: FunctionDefinition = {\n  name: \"AND\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length === 0) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"AND function requires at least one argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Process arguments one by one (like SUM function)\n    for (const arg of node.args) {\n      const argResult = this.evaluateNode(arg, context);\n\n      if (argResult.type === \"error\" || argResult.type === \"awaiting-evaluation\") {\n        return argResult;\n      }\n\n      if (argResult.type === \"value\") {\n        // Single value - check if truthy\n        if (!isTruthy(argResult.result)) {\n          return {\n            type: \"value\",\n            result: { type: \"boolean\", value: false },\n          };\n        }\n      } else if (argResult.type === \"spilled-values\") {\n        // Range - check all values in the range\n        const cellValues = argResult.evaluateAllCells.call(this, {\n          context,\n          origin: context.cellAddress,\n          evaluate: argResult.evaluate,\n          lookupOrder: \"col-major\",\n        });\n\n        if (cellValues.type === \"error\" || cellValues.type === \"awaiting-evaluation\") {\n          return cellValues;\n        }\n\n        for (const cellValue of cellValues.values) {\n          if (cellValue.result.type === \"error\") {\n            return cellValue.result;\n          }\n          if (cellValue.result.type === \"value\") {\n            if (!isTruthy(cellValue.result.result)) {\n              return {\n                type: \"value\",\n                result: { type: \"boolean\", value: false },\n              };\n            }\n          }\n        }\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid argument type for AND function\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // All arguments are truthy\n    return {\n      type: \"value\",\n      result: { type: \"boolean\", value: true },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,IAZP;AAuCA,SAAS,QAAQ,CAAC,OAA2B;AAAA,EAC3C,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,MAAM;AAAA,SACV;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO;AAAA;AAAA,MAEP,OAAO;AAAA;AAAA;AAUN,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,WAAW,OAAO,KAAK,MAAM;AAAA,MAC3B,MAAM,YAAY,KAAK,aAAa,KAAK,OAAO;AAAA,MAEhD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,QAC1E,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,UAAU,SAAS,SAAS;AAAA,QAE9B,IAAI,CAAC,SAAS,UAAU,MAAM,GAAG;AAAA,UAC/B,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,UAC1C;AAAA,QACF;AAAA,MACF,EAAO,SAAI,UAAU,SAAS,kBAAkB;AAAA,QAE9C,MAAM,aAAa,UAAU,iBAAiB,KAAK,MAAM;AAAA,UACvD;AAAA,UACA,QAAQ,QAAQ;AAAA,UAChB,UAAU,UAAU;AAAA,UACpB,aAAa;AAAA,QACf,CAAC;AAAA,QAED,IAAI,WAAW,SAAS,WAAW,WAAW,SAAS,uBAAuB;AAAA,UAC5E,OAAO;AAAA,QACT;AAAA,QAEA,WAAW,aAAa,WAAW,QAAQ;AAAA,UACzC,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,YACrC,OAAO,UAAU;AAAA,UACnB;AAAA,UACA,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,YACrC,IAAI,CAAC,SAAS,UAAU,OAAO,MAAM,GAAG;AAAA,cACtC,OAAO;AAAA,gBACL,MAAM;AAAA,gBACN,QAAQ,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,cAC1C;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF,EAAO;AAAA,QACL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,IAEJ;AAAA,IAGA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,IACzC;AAAA;AAEJ;",
+  "debugId": "A0E644E550D6D44364756E2164756E21",
+  "names": []
+}