@ricsam/formula-engine 0.0.1

package/dist/cjs/evaluator/evaluate-scalar-operator.cjs

@@ -0,0 +1,254 @@
+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/evaluator/evaluate-scalar-operator.ts
+var exports_evaluate_scalar_operator = {};
+__export(exports_evaluate_scalar_operator, {
+  evaluateScalarOperator: () => evaluateScalarOperator
+});
+module.exports = __toCommonJS(exports_evaluate_scalar_operator);
+var import_types = require("../core/types.cjs");
+function evaluateSingleScalarOperator(leftValue, rightValue, evaluateScalar, context) {
+  const result = evaluateScalar(leftValue, rightValue, context);
+  if (result.type === "error" || result.type === "awaiting-evaluation") {
+    return result;
+  }
+  return { type: "value", result };
+}
+function evaluateScalarOperator(left, right, options) {
+  const { evaluateScalar, context, name } = options;
+  if (left.type === "error" || left.type === "awaiting-evaluation") {
+    return left;
+  }
+  if (right.type === "error" || right.type === "awaiting-evaluation") {
+    return right;
+  }
+  if (left.type === "value" && right.type === "value") {
+    const leftValue = left.result;
+    const rightValue = right.result;
+    const result = evaluateScalar(leftValue, rightValue, options.context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    if (result) {
+      return { type: "value", result };
+    }
+  }
+  if (left.type === "spilled-values" && right.type === "value") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => left.spillArea(origin),
+      source: `evaulate left spilled range onto right value in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledLeft = left.evaluate(spilled, context2);
+        if (evaledLeft.type === "error" || evaledLeft.type === "awaiting-evaluation") {
+          return evaledLeft;
+        }
+        return evaluateSingleScalarOperator(evaledLeft.result, right.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const leftResults = left.evaluateAllCells.call(this, options2);
+        if (leftResults.type === "error" || leftResults.type === "awaiting-evaluation") {
+          return leftResults;
+        }
+        const results = leftResults.values.map((cellValue) => {
+          if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+            return cellValue;
+          } else {
+            return {
+              result: evaluateSingleScalarOperator(cellValue.result.result, right.result, evaluateScalar, options2.context),
+              relativePos: cellValue.relativePos
+            };
+          }
+        });
+        return {
+          type: "values",
+          values: results
+        };
+      }
+    };
+  }
+  if (right.type === "spilled-values" && left.type === "value") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => right.spillArea(origin),
+      source: `evaluate right spilled range onto left value in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledRight = right.evaluate(spilled, context2);
+        if (evaledRight.type === "error" || evaledRight.type === "awaiting-evaluation") {
+          return evaledRight;
+        }
+        return evaluateSingleScalarOperator(left.result, evaledRight.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const rightResults = right.evaluateAllCells.call(this, options2);
+        if (rightResults.type === "error" || rightResults.type === "awaiting-evaluation") {
+          return rightResults;
+        }
+        const results = rightResults.values.map((cellValue) => {
+          if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+            return cellValue;
+          } else {
+            const result = evaluateSingleScalarOperator(left.result, cellValue.result.result, evaluateScalar, options2.context);
+            return {
+              result,
+              relativePos: cellValue.relativePos
+            };
+          }
+        });
+        return {
+          type: "values",
+          values: results
+        };
+      }
+    };
+  }
+  if (left.type === "spilled-values" && right.type === "spilled-values") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => this.unionRanges(left.spillArea(origin), right.spillArea(origin)),
+      source: `evaluate spilled ranges in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledLeft = left.evaluate(spilled, context2);
+        if (evaledLeft.type === "error" || evaledLeft.type === "awaiting-evaluation") {
+          return evaledLeft;
+        }
+        const evaledRight = right.evaluate(spilled, context2);
+        if (evaledRight.type === "error" || evaledRight.type === "awaiting-evaluation") {
+          return evaledRight;
+        }
+        const isLeftEmpty = evaledLeft.type === "value" && evaledLeft.result.type === "string" && evaledLeft.result.value === "";
+        const isRightEmpty = evaledRight.type === "value" && evaledRight.result.type === "string" && evaledRight.result.value === "";
+        if (isLeftEmpty || isRightEmpty) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.NA,
+            message: "Empty cell in scalar operation",
+            errAddress: options.context.dependencyNode
+          };
+        }
+        return evaluateSingleScalarOperator(evaledLeft.result, evaledRight.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const leftResults = left.evaluateAllCells.call(this, options2);
+        if (leftResults.type === "error" || leftResults.type === "awaiting-evaluation") {
+          return leftResults;
+        }
+        const rightResults = right.evaluateAllCells.call(this, options2);
+        if (rightResults.type === "error" || rightResults.type === "awaiting-evaluation") {
+          return rightResults;
+        }
+        const leftMap = new Map;
+        const rightMap = new Map;
+        const allPositions = new Set;
+        for (const result of leftResults.values) {
+          const key = `${result.relativePos.x},${result.relativePos.y}`;
+          leftMap.set(key, result);
+          allPositions.add(key);
+        }
+        for (const result of rightResults.values) {
+          const key = `${result.relativePos.x},${result.relativePos.y}`;
+          rightMap.set(key, result);
+          allPositions.add(key);
+        }
+        const results = [];
+        for (const posKey of allPositions) {
+          const leftResult = leftMap.get(posKey);
+          const rightResult = rightMap.get(posKey);
+          const [x, y] = posKey.split(",").map(Number);
+          const relativePos = { x, y };
+          if (!leftResult && !rightResult) {
+            continue;
+          } else if (!leftResult && rightResult) {
+            if (rightResult.result.type === "error" || rightResult.result.type === "awaiting-evaluation") {
+              results.push(rightResult);
+            } else if (rightResult.result.type === "value") {
+              results.push({
+                result: {
+                  type: "error",
+                  err: import_types.FormulaError.NA,
+                  message: "Left operand is empty",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            } else {
+              results.push(rightResult);
+            }
+          } else if (!rightResult && leftResult) {
+            if (leftResult.result.type === "error" || leftResult.result.type === "awaiting-evaluation") {
+              results.push(leftResult);
+            } else if (leftResult.result.type === "value") {
+              results.push({
+                result: {
+                  type: "error",
+                  err: import_types.FormulaError.NA,
+                  message: "Right operand is empty",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            } else {
+              results.push(leftResult);
+            }
+          } else if (leftResult && rightResult) {
+            if (leftResult.result.type === "error" || leftResult.result.type === "awaiting-evaluation") {
+              results.push(leftResult);
+            } else if (rightResult.result.type === "error" || rightResult.result.type === "awaiting-evaluation") {
+              results.push(rightResult);
+            } else if (leftResult.result.type === "value" && rightResult.result.type === "value") {
+              results.push({
+                result: evaluateSingleScalarOperator(leftResult.result.result, rightResult.result.result, evaluateScalar, options2.context),
+                relativePos: leftResult.relativePos
+              });
+            } else {
+              results.push({
+                result: {
+                  type: "error",
+                  err: import_types.FormulaError.VALUE,
+                  message: "Cannot evaluate scalar operator on non-value results",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            }
+          }
+        }
+        return { type: "values", values: results };
+      }
+    };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: `Can't evaluate (${left.type}, ${right.type}) in scalar operator ${name}`,
+    errAddress: options.context.dependencyNode
+  };
+}
+
+//# debugId=7716B58A0A8FCC1E64756E2164756E21

package/dist/cjs/evaluator/evaluate-scalar-operator.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/evaluator/evaluate-scalar-operator.ts"],
+  "sourcesContent": [
+    "import type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport {\n  FormulaError,\n  type ArethmeticEvaluator,\n  type CellAddress,\n  type CellValue,\n  type CellInRangeResult,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n} from \"../core/types.cjs\";\nimport type { EvaluationContext } from \"./evaluation-context.cjs\";\n\nexport type EvaluateScalarOperatorOptions = {\n  evaluateScalar: ArethmeticEvaluator;\n  context: EvaluationContext;\n  /**\n   * for debugging messages\n   */\n  name: string;\n};\n\nfunction evaluateSingleScalarOperator(\n  leftValue: CellValue,\n  rightValue: CellValue,\n  evaluateScalar: ArethmeticEvaluator,\n  context: EvaluationContext\n): SingleEvaluationResult {\n  const result = evaluateScalar(leftValue, rightValue, context);\n  if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n    return result;\n  }\n  return { type: \"value\", result };\n}\n\nexport function evaluateScalarOperator(\n  this: FormulaEvaluator,\n  left: FunctionEvaluationResult,\n  right: FunctionEvaluationResult,\n  options: EvaluateScalarOperatorOptions\n): FunctionEvaluationResult {\n  const { evaluateScalar, context, name } = options;\n  if (left.type === \"error\" || left.type === \"awaiting-evaluation\") {\n    return left;\n  }\n  if (right.type === \"error\" || right.type === \"awaiting-evaluation\") {\n    return right;\n  }\n\n  if (left.type === \"value\" && right.type === \"value\") {\n    const leftValue = left.result;\n    const rightValue = right.result;\n    const result = evaluateScalar(leftValue, rightValue, options.context);\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n    if (result) {\n      return { type: \"value\", result };\n    }\n  }\n  if (left.type === \"spilled-values\" && right.type === \"value\") {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => left.spillArea(origin),\n      source: `evaulate left spilled range onto right value in scalar operator ${name}`,\n      evaluate: (spilled, context) => {\n        const evaledLeft = left.evaluate(spilled, context);\n        if (\n          evaledLeft.type === \"error\" ||\n          evaledLeft.type === \"awaiting-evaluation\"\n        ) {\n          return evaledLeft;\n        }\n        return evaluateSingleScalarOperator(\n          evaledLeft.result,\n          right.result,\n          evaluateScalar,\n          options.context\n        );\n      },\n      evaluateAllCells: function (options) {\n        const leftResults = left.evaluateAllCells.call(this, options);\n        if (\n          leftResults.type === \"error\" ||\n          leftResults.type === \"awaiting-evaluation\"\n        ) {\n          return leftResults;\n        }\n        const results = leftResults.values.map((cellValue) => {\n          if (\n            cellValue.result.type === \"error\" ||\n            cellValue.result.type === \"awaiting-evaluation\"\n          ) {\n            return cellValue;\n          } else {\n            return {\n              result: evaluateSingleScalarOperator(\n                cellValue.result.result,\n                right.result,\n                evaluateScalar,\n                options.context\n              ),\n              relativePos: cellValue.relativePos,\n            };\n          }\n        });\n        return {\n          type: \"values\",\n          values: results,\n        };\n      },\n    };\n  }\n  if (right.type === \"spilled-values\" && left.type === \"value\") {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin: CellAddress) => right.spillArea(origin),\n      source: `evaluate right spilled range onto left value in scalar operator ${name}`,\n      evaluate: (spilled, context) => {\n        const evaledRight = right.evaluate(spilled, context);\n        if (\n          evaledRight.type === \"error\" ||\n          evaledRight.type === \"awaiting-evaluation\"\n        ) {\n          return evaledRight;\n        }\n        return evaluateSingleScalarOperator(\n          left.result,\n          evaledRight.result,\n          evaluateScalar,\n          options.context\n        );\n      },\n      evaluateAllCells: function (options) {\n        const rightResults = right.evaluateAllCells.call(this, options);\n        if (\n          rightResults.type === \"error\" ||\n          rightResults.type === \"awaiting-evaluation\"\n        ) {\n          return rightResults;\n        }\n        const results = rightResults.values.map((cellValue) => {\n          if (\n            cellValue.result.type === \"error\" ||\n            cellValue.result.type === \"awaiting-evaluation\"\n          ) {\n            return cellValue;\n          } else {\n            const result = evaluateSingleScalarOperator(\n              left.result,\n              cellValue.result.result,\n              evaluateScalar,\n              options.context\n            );\n            return {\n              result: result,\n              relativePos: cellValue.relativePos,\n            };\n          }\n        });\n        return {\n          type: \"values\",\n          values: results,\n        };\n      },\n    };\n  }\n\n  if (left.type === \"spilled-values\" && right.type === \"spilled-values\") {\n    return {\n      type: \"spilled-values\",\n      spillArea: (origin) =>\n        this.unionRanges(left.spillArea(origin), right.spillArea(origin)),\n      source: `evaluate spilled ranges in scalar operator ${name}`,\n      evaluate: (spilled, context) => {\n        const evaledLeft = left.evaluate(spilled, context);\n        if (\n          evaledLeft.type === \"error\" ||\n          evaledLeft.type === \"awaiting-evaluation\"\n        ) {\n          return evaledLeft;\n        }\n        const evaledRight = right.evaluate(spilled, context);\n        if (\n          evaledRight.type === \"error\" ||\n          evaledRight.type === \"awaiting-evaluation\"\n        ) {\n          return evaledRight;\n        }\n\n        // Check if either value is an empty cell (empty string)\n        const isLeftEmpty =\n          evaledLeft.type === \"value\" &&\n          evaledLeft.result.type === \"string\" &&\n          evaledLeft.result.value === \"\";\n        const isRightEmpty =\n          evaledRight.type === \"value\" &&\n          evaledRight.result.type === \"string\" &&\n          evaledRight.result.value === \"\";\n\n        // If either operand is empty, return #N/A\n        if (isLeftEmpty || isRightEmpty) {\n          return {\n            type: \"error\",\n            err: FormulaError.NA,\n            message: \"Empty cell in scalar operation\",\n            errAddress: options.context.dependencyNode,\n          };\n        }\n\n        return evaluateSingleScalarOperator(\n          evaledLeft.result,\n          evaledRight.result,\n          evaluateScalar,\n          options.context\n        );\n      },\n      evaluateAllCells: function (options) {\n        const leftResults = left.evaluateAllCells.call(this, options);\n        if (\n          leftResults.type === \"error\" ||\n          leftResults.type === \"awaiting-evaluation\"\n        ) {\n          return leftResults;\n        }\n        const rightResults = right.evaluateAllCells.call(this, options);\n        if (\n          rightResults.type === \"error\" ||\n          rightResults.type === \"awaiting-evaluation\"\n        ) {\n          return rightResults;\n        }\n\n        // Create position-based maps for both left and right results\n        const leftMap = new Map<string, CellInRangeResult>();\n        const rightMap = new Map<string, CellInRangeResult>();\n        const allPositions = new Set<string>();\n\n        for (const result of leftResults.values) {\n          const key = `${result.relativePos.x},${result.relativePos.y}`;\n          leftMap.set(key, result);\n          allPositions.add(key);\n        }\n\n        for (const result of rightResults.values) {\n          const key = `${result.relativePos.x},${result.relativePos.y}`;\n          rightMap.set(key, result);\n          allPositions.add(key);\n        }\n\n        const results: CellInRangeResult[] = [];\n\n        // Process each unique position\n        for (const posKey of allPositions) {\n          const leftResult = leftMap.get(posKey);\n          const rightResult = rightMap.get(posKey);\n\n          // Extract relative position from the key\n          const [x, y] = posKey.split(\",\").map(Number);\n          const relativePos = { x: x!, y: y! };\n\n          if (!leftResult && !rightResult) {\n            // Both empty - this shouldn't happen as we only iterate positions that exist\n            continue;\n          } else if (!leftResult && rightResult) {\n            // Left is empty/missing, right has value\n            if (\n              rightResult.result.type === \"error\" ||\n              rightResult.result.type === \"awaiting-evaluation\"\n            ) {\n              results.push(rightResult);\n            } else if (rightResult.result.type === \"value\") {\n              // Treat missing left as empty, which is handled by the operator\n              results.push({\n                result: {\n                  type: \"error\",\n                  err: FormulaError.NA,\n                  message: \"Left operand is empty\",\n                  errAddress: context.dependencyNode,\n                },\n                relativePos,\n              });\n            } else {\n              results.push(rightResult);\n            }\n          } else if (!rightResult && leftResult) {\n            // Right is empty/missing, left has value\n            if (\n              leftResult.result.type === \"error\" ||\n              leftResult.result.type === \"awaiting-evaluation\"\n            ) {\n              results.push(leftResult);\n            } else if (leftResult.result.type === \"value\") {\n              // Treat missing right as empty, which is handled by the operator\n              results.push({\n                result: {\n                  type: \"error\",\n                  err: FormulaError.NA,\n                  message: \"Right operand is empty\",\n                  errAddress: context.dependencyNode,\n                },\n                relativePos,\n              });\n            } else {\n              results.push(leftResult);\n            }\n          } else if (leftResult && rightResult) {\n            // Both have values\n            if (\n              leftResult.result.type === \"error\" ||\n              leftResult.result.type === \"awaiting-evaluation\"\n            ) {\n              results.push(leftResult);\n            } else if (\n              rightResult.result.type === \"error\" ||\n              rightResult.result.type === \"awaiting-evaluation\"\n            ) {\n              results.push(rightResult);\n            } else if (\n              leftResult.result.type === \"value\" &&\n              rightResult.result.type === \"value\"\n            ) {\n              results.push({\n                result: evaluateSingleScalarOperator(\n                  leftResult.result.result,\n                  rightResult.result.result,\n                  evaluateScalar,\n                  options.context\n                ),\n                relativePos: leftResult.relativePos,\n              });\n            } else {\n              // Both are awaiting-evaluation or some other state\n              results.push({\n                result: {\n                  type: \"error\",\n                  err: FormulaError.VALUE,\n                  message:\n                    \"Cannot evaluate scalar operator on non-value results\",\n                  errAddress: context.dependencyNode,\n                },\n                relativePos,\n              });\n            }\n          }\n        }\n\n        return { type: \"values\", values: results };\n      },\n    };\n  }\n\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Can't evaluate (${left.type}, ${right.type}) in scalar operator ${name}`,\n    errAddress: options.context.dependencyNode,\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7716B58A0A8FCC1E64756E2164756E21",
+  "names": []
+}

package/dist/cjs/evaluator/evaluation-context.cjs

@@ -0,0 +1,154 @@
+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/evaluator/evaluation-context.ts
+var exports_evaluation_context = {};
+__export(exports_evaluation_context, {
+  keyFromDependency: () => keyFromDependency,
+  getContextDependencyKey: () => getContextDependencyKey,
+  eligibleKeysForContext: () => eligibleKeysForContext,
+  dependencyMatchesContext: () => dependencyMatchesContext,
+  contextDependencyKeys: () => contextDependencyKeys,
+  EvaluationContext: () => EvaluationContext
+});
+module.exports = __toCommonJS(exports_evaluation_context);
+
+class EvaluationContext {
+  _cellAddress;
+  _tableName;
+  _dependencyNode;
+  constructor(tableManager, dependencyNode, cellAddress) {
+    this._dependencyNode = dependencyNode;
+    this._cellAddress = cellAddress;
+    const table = tableManager.isCellInTable(cellAddress);
+    this._tableName = table?.name;
+  }
+  get dependencyNode() {
+    return this._dependencyNode;
+  }
+  _contextDependency = {};
+  getContextDependency() {
+    return this._contextDependency;
+  }
+  get cellAddress() {
+    return this._cellAddress;
+  }
+  get tableName() {
+    return this._tableName;
+  }
+  addContextDependency(...types) {
+    for (const type of types) {
+      switch (type) {
+        case "row":
+          this._contextDependency.rowIndex = this._cellAddress.rowIndex;
+          break;
+        case "col":
+          this._contextDependency.colIndex = this._cellAddress.colIndex;
+          break;
+        case "workbook":
+          this._contextDependency.workbookName = this._cellAddress.workbookName;
+          break;
+        case "sheet":
+          this._contextDependency.sheetName = this._cellAddress.sheetName;
+          break;
+        case "table":
+          this._contextDependency.tableName = this.tableName;
+          break;
+        default:
+          throw new Error(`Invalid context dependency type: ${type}`);
+      }
+    }
+  }
+  appendContextDependency(contextDependency) {
+    this._contextDependency = {
+      ...this._contextDependency,
+      ...Object.fromEntries(Object.entries(contextDependency).filter(([key, value]) => value !== undefined))
+    };
+  }
+}
+var contextDependencyKeys = [
+  "workbookName",
+  "sheetName",
+  "tableName",
+  "rowIndex",
+  "colIndex"
+];
+var DIM_ORDER = [
+  "workbookName",
+  "sheetName",
+  "tableName",
+  "rowIndex",
+  "colIndex"
+];
+function keyFromDependency(dep) {
+  return DIM_ORDER.map((k) => dep[k] !== undefined ? `${k}:[${dep[k]}]` : `${k}:*`).join(",");
+}
+function dependencyMatchesContext(ctx, dep) {
+  return DIM_ORDER.every((k) => dep[k] === undefined || dep[k] === ctx[k]);
+}
+var contextCacheKey = new Map;
+function eligibleKeysForContext(ctx) {
+  const mostRestrictiveKey = keyFromDependency(ctx);
+  const cachedKeys = contextCacheKey.get(mostRestrictiveKey);
+  if (cachedKeys) {
+    return cachedKeys;
+  }
+  const results = [];
+  const n = DIM_ORDER.length;
+  const tableIdx = DIM_ORDER.indexOf("tableName");
+  const totalMasks = 1 << n;
+  for (let mask = 0;mask < totalMasks; mask++) {
+    if (ctx.tableName === undefined && (mask >> tableIdx & 1) === 1)
+      continue;
+    const dep = {};
+    for (let i = 0;i < n; i++) {
+      if ((mask >> i & 1) === 1) {
+        const k = DIM_ORDER[i];
+        const v = ctx[k];
+        if (v !== undefined)
+          dep[k] = v;
+      }
+    }
+    results.push(keyFromDependency(dep));
+  }
+  contextCacheKey.set(mostRestrictiveKey, results);
+  return results;
+}
+function getContextDependencyKey(contextDependency) {
+  const keys = [];
+  contextDependencyKeys.forEach((key) => {
+    if (contextDependency[key] !== undefined) {
+      keys.push(`${key}:[${contextDependency[key]}]`);
+    } else {
+      keys.push(`${key}:*`);
+    }
+  });
+  return keys.join(",");
+}
+
+//# debugId=41AADC951D2144A964756E2164756E21

package/dist/cjs/evaluator/evaluation-context.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/evaluator/evaluation-context.ts"],
+  "sourcesContent": [
+    "import type { TableManager } from \"src/core/managers\";\nimport type { DependencyNode } from \"src/core/managers/dependency-node\";\nimport type { WorkbookManager } from \"src/core/managers/workbook-manager\";\nimport type { CellAddress } from \"src/core/types\";\n\nexport class EvaluationContext {\n  private _cellAddress: CellAddress;\n  private _tableName: string | undefined;\n  /**\n   * Can be a range or a cell\n   */\n  private _dependencyNode: DependencyNode;\n  constructor(\n    tableManager: TableManager,\n    dependencyNode: DependencyNode,\n    cellAddress: CellAddress\n  ) {\n    this._dependencyNode = dependencyNode;\n    this._cellAddress = cellAddress;\n    const table = tableManager.isCellInTable(cellAddress);\n    this._tableName = table?.name;\n  }\n\n  get dependencyNode() {\n    return this._dependencyNode;\n  }\n\n  private _contextDependency: ContextDependency = {};\n\n  getContextDependency() {\n    return this._contextDependency;\n  }\n\n  /**\n   * The cell context, the address of the cell being evaluated\n   * and the context in which results should be stored\n   */\n  get cellAddress() {\n    return this._cellAddress;\n  }\n\n  get tableName() {\n    return this._tableName;\n  }\n\n  addContextDependency(...types: ContextDependencyType[]) {\n    for (const type of types) {\n      switch (type) {\n        case \"row\":\n          this._contextDependency.rowIndex = this._cellAddress.rowIndex;\n          break;\n        case \"col\":\n          this._contextDependency.colIndex = this._cellAddress.colIndex;\n          break;\n        case \"workbook\":\n          this._contextDependency.workbookName = this._cellAddress.workbookName;\n          break;\n        case \"sheet\":\n          this._contextDependency.sheetName = this._cellAddress.sheetName;\n          break;\n        case \"table\":\n          this._contextDependency.tableName = this.tableName;\n          break;\n        default:\n          throw new Error(`Invalid context dependency type: ${type}`);\n      }\n    }\n  }\n\n  /**\n   * When evaluating an AST node,\n   * we need to append the subtree context\n   * dependencies to the current context dependency\n   */\n  appendContextDependency(contextDependency: ContextDependency) {\n    this._contextDependency = {\n      ...this._contextDependency,\n      ...Object.fromEntries(\n        Object.entries(contextDependency).filter(\n          ([key, value]) => value !== undefined\n        )\n      ),\n    };\n  }\n}\n\n/**\n * Each value has the same value as the origin cell\n * the defined keys are the ones the ast node is dependent on\n * e.g. A3=ROW() will have a context dependency of { rowIndex: 3 }\n *\n * The keys are ANDed together, e.g. { workbookName: \"Sheet1\", sheetName: \"Sheet2\" }\n * means the ast node is dependent on the workbook \"Sheet1\" and the sheet \"Sheet2\"\n */\nexport type ContextDependency = {\n  workbookName?: string;\n  sheetName?: string;\n  tableName?: string;\n  rowIndex?: number;\n  colIndex?: number;\n};\n\nexport const contextDependencyKeys = [\n  \"workbookName\",\n  \"sheetName\",\n  \"tableName\",\n  \"rowIndex\",\n  \"colIndex\",\n] as const;\n\n/**\n * These are some distinct scenarios where context dependencies are added\n */\nexport type ContextDependencyType =\n  | \"row\"\n  | \"col\"\n  | \"workbook\"\n  | \"sheet\"\n  | \"table\";\n\n// *  [astKey], // `=1+1`\n// *  [astKey, sheetKey, workbookKey], // `B3`\n// *  [astKey, workbookKey], // `Table1[Column1]`\n// *  [astKey, workbookKey], // `Sheet1!B3`\n// *  [astKey, cellAddress.rowIndex], // `ROW()`\n// *  [astKey, cellAddress.colIndex], // `COL()`\n// *  [astKey, cellAddress.rowIndex, cellAddress.colIndex] // `CELL(\"address\")`\n// *  [astKey, tableKey, cellAddress.rowIndex], // `@Column1`\n// *  [astKey, workbookKey, cellAddress.rowIndex], // `Table1[@Column1]`\n\ntype Dim = \"workbookName\" | \"sheetName\" | \"tableName\" | \"rowIndex\" | \"colIndex\";\nconst DIM_ORDER: readonly Dim[] = [\n  \"workbookName\",\n  \"sheetName\",\n  \"tableName\",\n  \"rowIndex\",\n  \"colIndex\",\n] as const;\n\n/** Build the canonical cache key string for a dependency. */\nexport function keyFromDependency(dep: ContextDependency): string {\n  return DIM_ORDER.map((k) =>\n    dep[k] !== undefined ? `${k}:[${(dep as any)[k]}]` : `${k}:*`\n  ).join(\",\");\n}\n\ntype Context = {\n  workbookName: string;\n  sheetName: string;\n  tableName?: string;\n  rowIndex: number;\n  colIndex: number;\n};\n\n/** True if `dep` matches `ctx` (i.e., every specified field equals the context’s field). */\nexport function dependencyMatchesContext(\n  ctx: Context,\n  dep: ContextDependency\n): boolean {\n  return DIM_ORDER.every(\n    (k) => dep[k] === undefined || (dep as any)[k] === (ctx as any)[k]\n  );\n}\n\nconst contextCacheKey = new Map<string, string[]>();\n\n/**\n * Generate every cache key that would be eligible for `ctx`.\n * By default returns keys ordered from most-specific to least-specific.\n */\nexport function eligibleKeysForContext(ctx: Context): string[] {\n  const mostRestrictiveKey = keyFromDependency(ctx);\n  const cachedKeys = contextCacheKey.get(mostRestrictiveKey);\n  if (cachedKeys) {\n    return cachedKeys;\n  }\n\n  const results: string[] = [];\n  const n = DIM_ORDER.length;\n\n  // If tableName is undefined in the context, we cannot create combos that \"specify\" it.\n  const tableIdx = DIM_ORDER.indexOf(\"tableName\");\n\n  const totalMasks = 1 << n; // 2^n\n  for (let mask = 0; mask < totalMasks; mask++) {\n    // Skip combos that specify tableName when ctx.tableName is undefined.\n    if (ctx.tableName === undefined && ((mask >> tableIdx) & 1) === 1) continue;\n\n    const dep: ContextDependency = {};\n    for (let i = 0; i < n; i++) {\n      if (((mask >> i) & 1) === 1) {\n        const k = DIM_ORDER[i];\n        const v = (ctx as any)[k!];\n        // Only assign when we actually have a value (guards tableName: undefined)\n        if (v !== undefined) (dep as any)[k!] = v;\n      }\n    }\n    results.push(keyFromDependency(dep));\n  }\n\n  contextCacheKey.set(mostRestrictiveKey, results);\n\n  return results;\n}\n\nexport function getContextDependencyKey(contextDependency: ContextDependency) {\n  const keys: (string | number)[] = [];\n  contextDependencyKeys.forEach((key) => {\n    if (contextDependency[key] !== undefined) {\n      keys.push(`${key}:[${contextDependency[key]}]`);\n    } else {\n      keys.push(`${key}:*`);\n    }\n  });\n  return keys.join(\",\");\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "41AADC951D2144A964756E2164756E21",
+  "names": []
+}

package/dist/cjs/evaluator/evaluation-error.cjs

@@ -0,0 +1,75 @@
+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/evaluator/evaluation-error.ts
+var exports_evaluation_error = {};
+__export(exports_evaluation_error, {
+  WorkbookNotFoundError: () => WorkbookNotFoundError,
+  SheetNotFoundError: () => SheetNotFoundError,
+  EvaluationError: () => EvaluationError,
+  AwaitingEvaluationError: () => AwaitingEvaluationError
+});
+module.exports = __toCommonJS(exports_evaluation_error);
+
+class EvaluationError extends Error {
+  type;
+  errAddress;
+  constructor(type, message, errAddress) {
+    super(message);
+    this.type = type;
+    this.errAddress = errAddress;
+  }
+}
+
+class AwaitingEvaluationError extends Error {
+  errAddress;
+  waitingFor;
+  constructor(errAddress, waitingFor) {
+    super(errAddress.key + " is awaiting evaluation of " + waitingFor.key);
+    this.errAddress = errAddress;
+    this.waitingFor = waitingFor;
+  }
+}
+
+class SheetNotFoundError extends Error {
+  sheetName;
+  constructor(sheetName) {
+    super("Sheet not found: " + sheetName);
+    this.sheetName = sheetName;
+  }
+}
+
+class WorkbookNotFoundError extends Error {
+  workbookName;
+  constructor(workbookName) {
+    super("Workbook not found: " + workbookName);
+    this.workbookName = workbookName;
+  }
+}
+
+//# debugId=64F9E65DD2C51CBE64756E2164756E21

package/dist/cjs/evaluator/evaluation-error.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/evaluator/evaluation-error.ts"],
+  "sourcesContent": [
+    "import type { DependencyNode } from \"src/core/managers/dependency-node\";\nimport type { CellAddress, FormulaError } from \"src/core/types\";\nimport { cellAddressToKey } from \"src/core/utils\";\n\nexport class EvaluationError extends Error {\n  constructor(\n    public readonly type: FormulaError,\n    message: string,\n    public readonly errAddress?: DependencyNode\n  ) {\n    super(message);\n  }\n}\n\nexport class AwaitingEvaluationError extends Error {\n  constructor(\n    public readonly errAddress: DependencyNode,\n    public readonly waitingFor: DependencyNode\n  ) {\n    super(errAddress.key + \" is awaiting evaluation of \" + waitingFor.key);\n  }\n}\n\nexport class SheetNotFoundError extends Error {\n  constructor(public readonly sheetName: string) {\n    super(\"Sheet not found: \" + sheetName);\n  }\n}\n\nexport class WorkbookNotFoundError extends Error {\n  constructor(public readonly workbookName: string) {\n    super(\"Workbook not found: \" + workbookName);\n  }\n}\n\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,MAAM,wBAAwB,MAAM;AAAA,EAEvB;AAAA,EAEA;AAAA,EAHlB,WAAW,CACO,MAChB,SACgB,YAChB;AAAA,IACA,MAAM,OAAO;AAAA,IAJG;AAAA,IAEA;AAAA;AAIpB;AAAA;AAEO,MAAM,gCAAgC,MAAM;AAAA,EAE/B;AAAA,EACA;AAAA,EAFlB,WAAW,CACO,YACA,YAChB;AAAA,IACA,MAAM,WAAW,MAAM,gCAAgC,WAAW,GAAG;AAAA,IAHrD;AAAA,IACA;AAAA;AAIpB;AAAA;AAEO,MAAM,2BAA2B,MAAM;AAAA,EAChB;AAAA,EAA5B,WAAW,CAAiB,WAAmB;AAAA,IAC7C,MAAM,sBAAsB,SAAS;AAAA,IADX;AAAA;AAG9B;AAAA;AAEO,MAAM,8BAA8B,MAAM;AAAA,EACnB;AAAA,EAA5B,WAAW,CAAiB,cAAsB;AAAA,IAChD,MAAM,yBAAyB,YAAY;AAAA,IADjB;AAAA;AAG9B;",
+  "debugId": "64F9E65DD2C51CBE64756E2164756E21",
+  "names": []
+}