@ricsam/formula-engine 0.0.1

package/dist/mjs/evaluator/formula-evaluator.mjs

@@ -0,0 +1,780 @@
+// src/evaluator/formula-evaluator.ts
+import { parseFormula } from "src/parser/parser";
+import {
+  FormulaError
+} from "../core/types.mjs";
+import {
+  evaluateScalarOperator
+} from "src/evaluator/evaluate-scalar-operator";
+import { functions } from "src/functions";
+import {
+  captureEvaluationErrors,
+  cellAddressToKey,
+  getAbsoluteRange,
+  getRangeIntersection,
+  getRangeKey,
+  getRelativeRange,
+  isRangeOneCell,
+  rangeAddressToKey
+} from "../core/utils.mjs";
+import { add } from "./arithmetic/add/add.mjs";
+import { divide } from "./arithmetic/divide/divide.mjs";
+import { multiply } from "./arithmetic/multiply/multiply.mjs";
+import { power } from "./arithmetic/power/power.mjs";
+import { subtract } from "./arithmetic/subtract/subtract.mjs";
+import { equals } from "./comparison/equals.mjs";
+import { greaterThan } from "./comparison/greater-than.mjs";
+import { greaterThanOrEqual } from "./comparison/greater-than-or-equal.mjs";
+import { lessThan } from "./comparison/less-than.mjs";
+import { lessThanOrEqual } from "./comparison/less-than-or-equal.mjs";
+import { notEquals } from "./comparison/not-equals.mjs";
+import { concatenate } from "./concatenation/concatenate.mjs";
+import { EvaluationContext } from "./evaluation-context.mjs";
+import { CellValueNode } from "./dependency-nodes/cell-value-node.mjs";
+
+class FormulaEvaluator {
+  tableManager;
+  dependencyManager;
+  namedExpressionManager;
+  constructor(tableManager, dependencyManager, namedExpressionManager) {
+    this.tableManager = tableManager;
+    this.dependencyManager = dependencyManager;
+    this.namedExpressionManager = namedExpressionManager;
+  }
+  evaluateFormula(formula, context) {
+    const ast = parseFormula(formula);
+    return captureEvaluationErrors(context.dependencyNode, () => {
+      const result = this.evaluateNode(ast, context);
+      return result;
+    });
+  }
+  evaluateNode(node, context) {
+    const currentContext = {
+      ...context.cellAddress,
+      tableName: context.tableName
+    };
+    const astNode = this.dependencyManager.getAstNode(node, currentContext);
+    context.dependencyNode.addDependency(astNode);
+    if (astNode.resolved) {
+      const astContextDependency2 = astNode.getContextDependency();
+      context.appendContextDependency(astContextDependency2);
+      return astNode.evaluationResult;
+    }
+    astNode.resetDirectDepsUpdated();
+    function runEvaluation(context2) {
+      switch (node.type) {
+        case "value":
+          return {
+            type: "value",
+            result: this.evaluateValue(node)
+          };
+        case "infinity":
+          return {
+            type: "value",
+            result: {
+              type: "infinity",
+              sign: "positive"
+            }
+          };
+        case "binary-op":
+          return this.evaluateBinaryOp(node, context2);
+        case "reference":
+          return this.evaluateReference(node, context2);
+        case "named-expression":
+          return this.evaluateNamedExpression(node, context2);
+        case "structured-reference":
+          return this.evaluateStructuredReference(node, context2);
+        case "function":
+          return this.evaluateFunction(node, context2);
+        case "range":
+          return this.evaluateRange(node, context2);
+        case "unary-op":
+          return this.evaluateUnaryOp(node, context2);
+        case "3d-range":
+          return this.evaluate3DRange(node, context2);
+        case "array":
+          return this.evaluateArray(node, context2);
+        default:
+          return {
+            type: "error",
+            err: FormulaError.ERROR,
+            message: "WIP: unimplemented support for " + node.type,
+            errAddress: context2.dependencyNode
+          };
+      }
+    }
+    const newContext = new EvaluationContext(this.tableManager, astNode, context.cellAddress);
+    const result = captureEvaluationErrors(astNode, () => runEvaluation.call(this, newContext));
+    astNode.setEvaluationResult(result);
+    const astContextDependency = newContext.getContextDependency();
+    astNode.setContextDependency(astContextDependency);
+    context.appendContextDependency(astContextDependency);
+    return result;
+  }
+  evaluateStructuredReference(node, context) {
+    let table;
+    if (node.tableName && node.workbookName) {
+      table = this.tableManager.getTables(node.workbookName).get(node.tableName);
+    } else if (node.tableName) {
+      context.addContextDependency("workbook");
+      table = this.tableManager.getTables(context.cellAddress.workbookName).get(node.tableName);
+    } else {
+      context.addContextDependency("workbook", "table");
+      table = this.tableManager.isCellInTable(context.cellAddress);
+    }
+    if (node.isCurrentRow) {
+      context.addContextDependency("row");
+    }
+    if (!table) {
+      return {
+        type: "error",
+        err: FormulaError.REF,
+        message: `Table ${node.tableName} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowIndex = context.cellAddress.rowIndex;
+    const tableStart = table.start;
+    if (node.selector) {
+      let startRow;
+      let endRow;
+      switch (node.selector) {
+        case "#Headers":
+          startRow = table.start.rowIndex;
+          endRow = { type: "number", value: table.start.rowIndex };
+          break;
+        case "#Data":
+          startRow = table.start.rowIndex + 1;
+          endRow = table.endRow;
+          break;
+        case "#All":
+          startRow = table.start.rowIndex;
+          endRow = table.endRow;
+          break;
+        default:
+          return {
+            type: "error",
+            err: FormulaError.REF,
+            message: `Unknown table selector: ${node.selector}`,
+            errAddress: context.dependencyNode
+          };
+      }
+      if (node.cols) {
+        const startCol = table.headers.get(node.cols.startCol);
+        const endCol = table.headers.get(node.cols.endCol);
+        if (!startCol || !endCol) {
+          return {
+            type: "error",
+            err: FormulaError.REF,
+            message: `Column ${node.cols.startCol} or ${node.cols.endCol} not found in table ${table.name}`,
+            errAddress: context.dependencyNode
+          };
+        }
+        const startColIndex = tableStart.colIndex + startCol.index;
+        const endColIndex = tableStart.colIndex + endCol.index;
+        const range = {
+          start: {
+            row: startRow,
+            col: startColIndex
+          },
+          end: {
+            row: endRow,
+            col: { type: "number", value: endColIndex }
+          }
+        };
+        return this.evaluateRange({
+          type: "range",
+          range,
+          isAbsolute: {
+            start: {
+              col: true,
+              row: true
+            },
+            end: {
+              col: true,
+              row: true
+            }
+          },
+          sheetName: table.sheetName
+        }, context);
+      } else {
+        const range = {
+          start: {
+            row: startRow,
+            col: tableStart.colIndex
+          },
+          end: {
+            row: endRow,
+            col: {
+              type: "number",
+              value: tableStart.colIndex + table.headers.size - 1
+            }
+          }
+        };
+        return this.evaluateRange({
+          type: "range",
+          range,
+          isAbsolute: {
+            start: {
+              col: true,
+              row: true
+            },
+            end: {
+              col: true,
+              row: true
+            }
+          },
+          sheetName: table.sheetName
+        }, context);
+      }
+    }
+    if (node.cols) {
+      const startCol = table.headers.get(node.cols.startCol);
+      const endCol = table.headers.get(node.cols.endCol);
+      if (!startCol || !endCol) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: `Column ${node.cols.startCol} or ${node.cols.endCol} not found in table ${table.name}`,
+          errAddress: context.dependencyNode
+        };
+      }
+      const startColIndex = tableStart.colIndex + startCol.index;
+      const endColIndex = tableStart.colIndex + endCol.index;
+      const range = {
+        start: {
+          row: node.isCurrentRow ? rowIndex : table.start.rowIndex + 1,
+          col: startColIndex
+        },
+        end: {
+          row: node.isCurrentRow ? { type: "number", value: rowIndex } : table.endRow,
+          col: { type: "number", value: endColIndex }
+        }
+      };
+      return this.evaluateRange({
+        type: "range",
+        range,
+        isAbsolute: {
+          start: {
+            col: true,
+            row: true
+          },
+          end: {
+            col: true,
+            row: true
+          }
+        },
+        sheetName: table.sheetName
+      }, context);
+    }
+    return {
+      type: "error",
+      err: FormulaError.REF,
+      message: "Structured reference must specify either a selector or columns",
+      errAddress: context.dependencyNode
+    };
+  }
+  evaluateValue(node) {
+    return node.value;
+  }
+  evaluate3DRange(node, context) {
+    throw new Error("WIP: 3d range is not implemented");
+  }
+  evaluateRange(node, context) {
+    if (isRangeOneCell(node.range)) {
+      return this.evaluateReference({
+        type: "reference",
+        address: {
+          colIndex: node.range.start.col,
+          rowIndex: node.range.start.row
+        },
+        isAbsolute: {
+          col: node.isAbsolute.start.col || node.isAbsolute.end.col,
+          row: node.isAbsolute.start.row || node.isAbsolute.end.row
+        },
+        sheetName: node.sheetName
+      }, context);
+    }
+    const debugRange = getRangeKey(node.range);
+    const rangeAddress = {
+      sheetName: node.sheetName ?? context.cellAddress.sheetName,
+      workbookName: node.workbookName ?? context.cellAddress.workbookName,
+      range: node.range
+    };
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => this.projectRange(node.range, origin),
+      source: `range ${debugRange}`,
+      sourceRange: rangeAddress,
+      evaluate: (spillOffset, context2) => {
+        if (!node.sheetName && !node.workbookName) {
+          context2.addContextDependency("workbook", "sheet");
+        } else if (!node.sheetName) {
+          context2.addContextDependency("sheet");
+        } else if (!node.workbookName) {
+          context2.addContextDependency("workbook");
+        } else {}
+        const originSheetName = node.sheetName ?? context2.cellAddress.sheetName;
+        const originWorkbookName = node.workbookName ?? context2.cellAddress.workbookName;
+        const colIndex = node.range.start.col + spillOffset.x;
+        const rowIndex = node.range.start.row + spillOffset.y;
+        const cellAddress = {
+          colIndex,
+          rowIndex,
+          sheetName: originSheetName,
+          workbookName: originWorkbookName
+        };
+        const evalNode = this.dependencyManager.getCellValueOrEmptyCellNode(cellAddressToKey(cellAddress));
+        context2.dependencyNode.addDependency(evalNode);
+        const result = evalNode.evaluationResult;
+        return result;
+      },
+      evaluateAllCells: function({
+        evaluate,
+        intersection,
+        context: context2,
+        origin,
+        lookupOrder
+      }) {
+        let range = node.range;
+        if (intersection) {
+          const relativeRange = getRelativeRange(intersection, origin);
+          const start = {
+            colIndex: node.range.start.col,
+            rowIndex: node.range.start.row
+          };
+          const projectedIntersection = getAbsoluteRange(relativeRange, start);
+          const calculateIntersection = getRangeIntersection(node.range, projectedIntersection);
+          if (calculateIntersection) {
+            range = calculateIntersection;
+          }
+        }
+        const address = {
+          range,
+          sheetName: node.sheetName ?? context2.cellAddress.sheetName,
+          workbookName: node.workbookName ?? context2.cellAddress.workbookName
+        };
+        const rangeNode = this.dependencyManager.getRangeNode(rangeAddressToKey(address));
+        context2.dependencyNode.addDependency(rangeNode);
+        return this.dependencyManager.getRangeNode(rangeAddressToKey(address)).result;
+      }
+    };
+  }
+  evaluateArray(node, context) {
+    const firstRow = node.elements[0];
+    if (!firstRow) {
+      return {
+        type: "error",
+        err: FormulaError.REF,
+        message: "Array is empty",
+        errAddress: context.dependencyNode
+      };
+    }
+    const firstCell = firstRow[0];
+    if (!firstCell) {
+      return {
+        type: "error",
+        err: FormulaError.REF,
+        message: "Array is empty",
+        errAddress: context.dependencyNode
+      };
+    }
+    const originResult = this.evaluateNode(firstCell, context);
+    if (originResult.type === "error" || originResult.type === "awaiting-evaluation") {
+      return originResult;
+    }
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => ({
+        start: {
+          col: origin.colIndex,
+          row: origin.rowIndex
+        },
+        end: {
+          col: {
+            type: "number",
+            value: origin.colIndex + firstRow.length - 1
+          },
+          row: {
+            type: "number",
+            value: origin.rowIndex + node.elements.length - 1
+          }
+        }
+      }),
+      source: `array`,
+      evaluate: (spillOffset, context2) => {
+        const row = node.elements[spillOffset.y];
+        if (!row) {
+          return {
+            type: "error",
+            err: FormulaError.REF,
+            message: "Array is empty",
+            errAddress: context2.dependencyNode
+          };
+        }
+        const cell = row[spillOffset.x];
+        if (!cell) {
+          return {
+            type: "error",
+            err: FormulaError.REF,
+            message: "Array is empty",
+            errAddress: context2.dependencyNode
+          };
+        }
+        const result = this.evaluateNode(cell, context2);
+        if (result.type === "spilled-values") {
+          return {
+            type: "error",
+            err: FormulaError.VALUE,
+            message: "Arrays cannot contain spilled values",
+            errAddress: context2.dependencyNode
+          };
+        }
+        return result;
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for array is not implemented");
+      }
+    };
+  }
+  evaluateUnaryOp(node, context) {
+    const operandResult = this.evaluateNode(node.operand, context);
+    if (operandResult.type === "error" || operandResult.type === "awaiting-evaluation") {
+      return operandResult;
+    }
+    if (operandResult.type === "spilled-values") {
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => operandResult.spillArea(origin),
+        source: `unary ${node.operator} operation`,
+        evaluate: (spilledCell, context2) => {
+          const spillResult = operandResult.evaluate(spilledCell, context2);
+          if (!spillResult || spillResult.type === "error" || spillResult.type === "awaiting-evaluation") {
+            return spillResult;
+          }
+          if (spillResult.type !== "value") {
+            return {
+              type: "error",
+              err: FormulaError.VALUE,
+              message: "Invalid spilled result for unary operation",
+              errAddress: context2.dependencyNode
+            };
+          }
+          return this.evaluateUnaryScalar(node.operator, spillResult.result, context2);
+        },
+        evaluateAllCells: function(options) {
+          const cellValues = operandResult.evaluateAllCells.call(this, options);
+          if (cellValues.type !== "values") {
+            return cellValues;
+          }
+          return {
+            type: "values",
+            values: cellValues.values.map((cellValue) => {
+              if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+                return cellValue;
+              } else {
+                return {
+                  result: this.evaluateUnaryScalar(node.operator, cellValue.result.result, context),
+                  relativePos: cellValue.relativePos
+                };
+              }
+            })
+          };
+        }
+      };
+    }
+    if (operandResult.type === "value") {
+      return this.evaluateUnaryScalar(node.operator, operandResult.result, context);
+    }
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Invalid operand for unary operation",
+      errAddress: context.dependencyNode
+    };
+  }
+  evaluateUnaryScalar(operator, operand, context) {
+    if (operand.type !== "number" && operand.type !== "infinity") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: `Cannot apply unary ${operator} to non-number`,
+        errAddress: context.dependencyNode
+      };
+    }
+    if (operand.type === "infinity") {
+      if (operator === "%") {
+        return {
+          type: "error",
+          err: FormulaError.NUM,
+          message: "Cannot apply % to infinity",
+          errAddress: context.dependencyNode
+        };
+      }
+      return {
+        type: "value",
+        result: {
+          type: "infinity",
+          sign: operator === "+" ? "positive" : "negative"
+        }
+      };
+    }
+    switch (operator) {
+      case "+":
+        return { type: "value", result: operand };
+      case "-":
+        return {
+          type: "value",
+          result: {
+            type: "number",
+            value: -operand.value
+          }
+        };
+      case "%":
+        return {
+          type: "value",
+          result: { type: "number", value: operand.value / 100 }
+        };
+      default:
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: `Unknown unary operator: ${operator}`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+  evaluateBinaryOp(node, context) {
+    const left = this.evaluateNode(node.left, context);
+    const right = this.evaluateNode(node.right, context);
+    if (left.type === "error" || left.type === "awaiting-evaluation") {
+      return left;
+    }
+    if (right.type === "error" || right.type === "awaiting-evaluation") {
+      return right;
+    }
+    return this.evaluateBinaryScalar(node.operator, left, right, context);
+  }
+  evaluateReference(node, context) {
+    const cellAddress = {
+      ...node.address,
+      sheetName: node.sheetName ?? context.cellAddress.sheetName,
+      workbookName: node.workbookName ?? context.cellAddress.workbookName
+    };
+    const key = cellAddressToKey(cellAddress);
+    const evalNode = this.dependencyManager.getCellValueOrEmptyCellNode(key);
+    context.dependencyNode.addDependency(evalNode);
+    if (!node.sheetName && !node.workbookName) {
+      context.addContextDependency("workbook", "sheet");
+    } else if (!node.sheetName) {
+      context.addContextDependency("sheet");
+    } else if (!node.workbookName) {
+      context.addContextDependency("workbook");
+    } else {}
+    if (evalNode instanceof CellValueNode && evalNode.spillMeta) {
+      if (evalNode.spillMeta.evaluationResult.type === "spilled-values") {
+        return {
+          ...evalNode.spillMeta.evaluationResult,
+          sourceCell: cellAddress,
+          sourceRange: undefined
+        };
+      }
+    }
+    return { ...evalNode.evaluationResult, sourceCell: cellAddress };
+  }
+  evaluateNamedExpression(node, context) {
+    const expression = this.namedExpressionManager.resolveNamedExpression(node, context);
+    if (!expression) {
+      return {
+        type: "error",
+        err: FormulaError.NAME,
+        message: `Named expression ${node.name} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return this.evaluateFormula(expression, context);
+  }
+  evaluateBinaryScalar(operator, left, right, context) {
+    switch (operator) {
+      case "+":
+        return this.add(left, right, context);
+      case "-":
+        return this.subtract(left, right, context);
+      case "*":
+        return this.multiply(left, right, context);
+      case "/":
+        return this.divide(left, right, context);
+      case "^":
+        return this.power(left, right, context);
+      case "&":
+        return this.concatenateOp(left, right, context);
+      case "=":
+        return this.equalsOp(left, right, context);
+      case "<>":
+        return this.notEqualsOp(left, right, context);
+      case "<":
+        return this.lessThanOp(left, right, context);
+      case "<=":
+        return this.lessThanOrEqualOp(left, right, context);
+      case ">":
+        return this.greaterThanOp(left, right, context);
+      case ">=":
+        return this.greaterThanOrEqualOp(left, right, context);
+      default:
+        return {
+          type: "error",
+          err: FormulaError.ERROR,
+          message: `Unknown binary operator: ${operator}`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+  evaluateFunction(node, context) {
+    const func = functions[node.name];
+    if (!func) {
+      return {
+        type: "error",
+        err: FormulaError.NAME,
+        message: `Function ${node.name} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return func.evaluate.call(this, node, context);
+  }
+  add(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: add,
+      context,
+      name: "add"
+    });
+  }
+  multiply(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: multiply,
+      context,
+      name: "multiply"
+    });
+  }
+  divide(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: divide,
+      context,
+      name: "divide"
+    });
+  }
+  evaluateScalarOperator(left, right, options) {
+    return evaluateScalarOperator.call(this, left, right, options);
+  }
+  subtract(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: subtract,
+      context,
+      name: "subtract"
+    });
+  }
+  power(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: power,
+      context,
+      name: "power"
+    });
+  }
+  equalsOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: equals,
+      context,
+      name: "equals"
+    });
+  }
+  notEqualsOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: notEquals,
+      context,
+      name: "notEquals"
+    });
+  }
+  lessThanOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: lessThan,
+      context,
+      name: "lessThan"
+    });
+  }
+  lessThanOrEqualOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: lessThanOrEqual,
+      context,
+      name: "lessThanOrEqual"
+    });
+  }
+  greaterThanOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: greaterThan,
+      context,
+      name: "greaterThan"
+    });
+  }
+  greaterThanOrEqualOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: greaterThanOrEqual,
+      context,
+      name: "greaterThanOrEqual"
+    });
+  }
+  concatenateOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: concatenate,
+      context,
+      name: "concatenate"
+    });
+  }
+  projectRange(range, originCellAddress) {
+    const offsetLeft = originCellAddress.colIndex - range.start.col;
+    const offsetTop = originCellAddress.rowIndex - range.start.row;
+    return {
+      start: {
+        col: range.start.col + offsetLeft,
+        row: range.start.row + offsetTop
+      },
+      end: {
+        col: range.end.col.type === "number" ? { type: "number", value: range.end.col.value + offsetLeft } : range.end.col,
+        row: range.end.row.type === "number" ? { type: "number", value: range.end.row.value + offsetTop } : range.end.row
+      }
+    };
+  }
+  unionRanges(range1, range2) {
+    const endCol = (() => {
+      if (range1.end.col.type === "infinity" || range2.end.col.type === "infinity") {
+        return { type: "infinity", sign: "positive" };
+      }
+      return {
+        type: "number",
+        value: Math.max(range1.end.col.value, range2.end.col.value)
+      };
+    })();
+    const endRow = (() => {
+      if (range1.end.row.type === "infinity" || range2.end.row.type === "infinity") {
+        return { type: "infinity", sign: "positive" };
+      }
+      return {
+        type: "number",
+        value: Math.max(range1.end.row.value, range2.end.row.value)
+      };
+    })();
+    return {
+      start: {
+        col: Math.min(range1.start.col, range2.start.col),
+        row: Math.min(range1.start.row, range2.start.row)
+      },
+      end: {
+        col: endCol,
+        row: endRow
+      }
+    };
+  }
+}
+export {
+  FormulaEvaluator
+};
+
+//# debugId=F36CB37FEF9B983164756E2164756E21