@ricsam/formula-engine 0.2.2 → 0.2.3

package/dist/cjs/core/managers/evaluation-manager.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -44,6 +54,7 @@ var import_utils = require("../utils.cjs");
 var import_spill_meta_node = require("../../evaluator/dependency-nodes/spill-meta-node.cjs");
 var import_empty_cell_evaluation_node = require("../../evaluator/dependency-nodes/empty-cell-evaluation-node.cjs");
 var import_virtual_cell_value_node = require("../../evaluator/dependency-nodes/virtual-cell-value-node.cjs");
+var import_resource_dependency_node = require("../../evaluator/dependency-nodes/resource-dependency-node.cjs");
 
 class EvaluationManager {
   workbookManager;
@@ -60,6 +71,9 @@ class EvaluationManager {
   clearEvaluationCache() {
     this.dependencyManager.clearEvaluationCache();
   }
+  invalidateFromMutation(footprint) {
+    this.dependencyManager.invalidateFromMutation(footprint);
+  }
   evaluationResultToSerializedValue(evaluation, cellAddress, debug) {
     if (evaluation.type !== "error" && evaluation.type !== "awaiting-evaluation") {
       const value = evaluation.result;
@@ -77,14 +91,250 @@ class EvaluationManager {
     }
     return evaluation.err;
   }
+  buildSnapshotOrigin(node) {
+    if ("cellAddress" in node) {
+      return node.cellAddress;
+    }
+    const contextDependency = node.getContextDependency();
+    return {
+      workbookName: contextDependency.workbookName ?? "__snapshot__",
+      sheetName: contextDependency.sheetName ?? "__snapshot__",
+      colIndex: contextDependency.colIndex ?? 0,
+      rowIndex: contextDependency.rowIndex ?? 0
+    };
+  }
+  serializeErrorEvaluationResultSnapshot(evaluation, getNodeSnapshotId) {
+    return {
+      type: "error",
+      err: evaluation.err,
+      message: evaluation.message,
+      errAddressId: getNodeSnapshotId(evaluation.errAddress),
+      sourceCell: evaluation.sourceCell
+    };
+  }
+  serializeSingleEvaluationResultSnapshot(evaluation, getNodeSnapshotId) {
+    if (evaluation.type === "awaiting-evaluation") {
+      return;
+    }
+    if (evaluation.type === "error") {
+      return this.serializeErrorEvaluationResultSnapshot(evaluation, getNodeSnapshotId);
+    }
+    return {
+      type: "value",
+      result: evaluation.result,
+      sourceCell: evaluation.sourceCell
+    };
+  }
+  deserializeSingleEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId) {
+    if (evaluation.type === "error") {
+      return {
+        type: "error",
+        err: evaluation.err,
+        message: evaluation.message,
+        errAddress: resolveNodeSnapshotId(evaluation.errAddressId),
+        sourceCell: evaluation.sourceCell
+      };
+    }
+    return {
+      type: "value",
+      result: evaluation.result,
+      sourceCell: evaluation.sourceCell
+    };
+  }
+  serializeEvaluateAllCellsResultSnapshot(evaluation, getNodeSnapshotId) {
+    if (evaluation.type === "awaiting-evaluation") {
+      return;
+    }
+    if (evaluation.type === "error") {
+      return this.serializeErrorEvaluationResultSnapshot(evaluation, getNodeSnapshotId);
+    }
+    const values = [];
+    for (const value of evaluation.values) {
+      const serialized = this.serializeSingleEvaluationResultSnapshot(value.result, getNodeSnapshotId);
+      if (!serialized) {
+        return;
+      }
+      values.push({
+        relativePos: value.relativePos,
+        result: serialized
+      });
+    }
+    return {
+      type: "values",
+      values
+    };
+  }
+  deserializeEvaluateAllCellsResultSnapshot(evaluation, resolveNodeSnapshotId) {
+    if (evaluation.type === "error") {
+      return this.deserializeSingleEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId);
+    }
+    return {
+      type: "values",
+      values: evaluation.values.map((value) => ({
+        relativePos: value.relativePos,
+        result: this.deserializeSingleEvaluationResultSnapshot(value.result, resolveNodeSnapshotId)
+      }))
+    };
+  }
+  serializeFunctionEvaluationResultSnapshot(evaluation, options) {
+    if (evaluation.type !== "spilled-values") {
+      return this.serializeSingleEvaluationResultSnapshot(evaluation, options.getNodeSnapshotId);
+    }
+    const origin = this.buildSnapshotOrigin(options.sourceNode);
+    const spillArea = evaluation.spillArea(origin);
+    const relativeSpillArea = import_utils.getRelativeRange(spillArea, {
+      colIndex: origin.colIndex,
+      rowIndex: origin.rowIndex
+    });
+    if (evaluation.sourceRange) {
+      return {
+        type: "spilled-values",
+        spill: {
+          kind: "source-range",
+          relativeSpillArea,
+          source: evaluation.source,
+          sourceCell: evaluation.sourceCell,
+          sourceRange: evaluation.sourceRange
+        }
+      };
+    }
+    if (relativeSpillArea.width.type !== "number" || relativeSpillArea.height.type !== "number") {
+      return;
+    }
+    const context = new import_evaluation_context.EvaluationContext(this.tableManager, options.sourceNode, origin);
+    const values = [];
+    for (let y = 0;y < relativeSpillArea.height.value; y++) {
+      for (let x = 0;x < relativeSpillArea.width.value; x++) {
+        const result = import_utils.captureEvaluationErrors(options.sourceNode, () => evaluation.evaluate({ x, y }, context));
+        const serialized = this.serializeSingleEvaluationResultSnapshot(result, options.getNodeSnapshotId);
+        if (!serialized) {
+          return;
+        }
+        values.push({
+          relativePos: { x, y },
+          result: serialized
+        });
+      }
+    }
+    return {
+      type: "spilled-values",
+      spill: {
+        kind: "materialized",
+        relativeSpillArea,
+        source: evaluation.source,
+        sourceCell: evaluation.sourceCell,
+        sourceRange: evaluation.sourceRange,
+        values
+      }
+    };
+  }
+  deserializeFunctionEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId) {
+    if (evaluation.type !== "spilled-values") {
+      return this.deserializeSingleEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId);
+    }
+    const spillSnapshot = evaluation.spill;
+    if (spillSnapshot.kind === "materialized") {
+      const values = new Map(spillSnapshot.values.map((value) => [
+        `${value.relativePos.x},${value.relativePos.y}`,
+        this.deserializeSingleEvaluationResultSnapshot(value.result, resolveNodeSnapshotId)
+      ]));
+      return {
+        type: "spilled-values",
+        source: spillSnapshot.source,
+        sourceCell: spillSnapshot.sourceCell,
+        sourceRange: spillSnapshot.sourceRange,
+        spillArea: (origin) => import_utils.getAbsoluteRange(spillSnapshot.relativeSpillArea, {
+          colIndex: origin.colIndex,
+          rowIndex: origin.rowIndex
+        }),
+        evaluate: (spillOffset) => values.get(`${spillOffset.x},${spillOffset.y}`) ?? {
+          type: "value",
+          result: this.convertScalarValueToCellValue("")
+        },
+        evaluateAllCells: () => ({
+          type: "values",
+          values: spillSnapshot.values.map((value) => ({
+            relativePos: value.relativePos,
+            result: this.deserializeSingleEvaluationResultSnapshot(value.result, resolveNodeSnapshotId)
+          }))
+        })
+      };
+    }
+    return {
+      type: "spilled-values",
+      source: spillSnapshot.source,
+      sourceCell: spillSnapshot.sourceCell,
+      sourceRange: spillSnapshot.sourceRange,
+      spillArea: (origin) => import_utils.getAbsoluteRange(spillSnapshot.relativeSpillArea, {
+        colIndex: origin.colIndex,
+        rowIndex: origin.rowIndex
+      }),
+      evaluate: (spillOffset, context) => {
+        const cellAddress = {
+          workbookName: spillSnapshot.sourceRange.workbookName,
+          sheetName: spillSnapshot.sourceRange.sheetName,
+          colIndex: spillSnapshot.sourceRange.range.start.col + spillOffset.x,
+          rowIndex: spillSnapshot.sourceRange.range.start.row + spillOffset.y
+        };
+        const evalNode = this.dependencyManager.getCellValueOrEmptyCellNode(import_utils.cellAddressToKey(cellAddress));
+        context.dependencyNode.addDependency(evalNode);
+        return evalNode.evaluationResult;
+      },
+      evaluateAllCells: ({ intersection, context, origin }) => {
+        let range = spillSnapshot.sourceRange.range;
+        if (intersection) {
+          const relativeRange = import_utils.getRelativeRange(intersection, origin);
+          const projectedIntersection = import_utils.getAbsoluteRange(relativeRange, {
+            colIndex: spillSnapshot.sourceRange.range.start.col,
+            rowIndex: spillSnapshot.sourceRange.range.start.row
+          });
+          const nextRange = import_utils.getRangeIntersection(spillSnapshot.sourceRange.range, projectedIntersection);
+          if (nextRange) {
+            range = nextRange;
+          }
+        }
+        const rangeAddress = {
+          workbookName: spillSnapshot.sourceRange.workbookName,
+          sheetName: spillSnapshot.sourceRange.sheetName,
+          range
+        };
+        const rangeNode = this.dependencyManager.getRangeNode(import_utils.rangeAddressToKey(rangeAddress));
+        context.dependencyNode.addDependency(rangeNode);
+        return rangeNode.result;
+      }
+    };
+  }
+  serializeSpillMetaEvaluationResultSnapshot(evaluation, options) {
+    if (evaluation.type === "does-not-spill") {
+      return { type: "does-not-spill" };
+    }
+    if (evaluation.type === "error") {
+      return this.serializeErrorEvaluationResultSnapshot(evaluation, options.getNodeSnapshotId);
+    }
+    const serialized = this.serializeFunctionEvaluationResultSnapshot(evaluation, options);
+    if (!serialized || serialized.type !== "spilled-values") {
+      return;
+    }
+    return serialized;
+  }
+  deserializeSpillMetaEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId) {
+    if (evaluation.type === "does-not-spill") {
+      return evaluation;
+    }
+    if (evaluation.type === "error") {
+      return this.deserializeSingleEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId);
+    }
+    return this.deserializeFunctionEvaluationResultSnapshot(evaluation, resolveNodeSnapshotId);
+  }
   evaluateEmptyCell(node) {
-    node.resetDirectDepsUpdated();
     if (node.resolved) {
       const result = node.evaluationResult;
       if (result && result.type !== "awaiting-evaluation") {
         return;
       }
     }
+    this.dependencyManager.unregisterNode(node);
+    node.resetDirectDepsUpdated();
     const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, node.cellAddress);
     const inSpilled = this.dependencyManager.getSpillValue(node.cellAddress);
     if (inSpilled) {
@@ -107,11 +357,13 @@ class EvaluationManager {
       };
       node.setEvaluationResult(evaluationResult);
     }
+    this.dependencyManager.registerNode(node);
   }
   evaluateRangeNode(node) {
     if (node.resolved) {
       return;
     }
+    this.dependencyManager.unregisterNode(node);
     node.resetDirectDepsUpdated();
     const result = import_utils.captureEvaluationErrors(node, () => {
       node.upgradeFrontierDependencies();
@@ -175,11 +427,15 @@ class EvaluationManager {
       };
     });
     node.setResult(result);
+    this.dependencyManager.registerNode(node);
   }
   evaluateCellNode(node) {
     if (node.resolved) {
       return;
     }
+    if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+      this.dependencyManager.unregisterNode(node);
+    }
     node.resetDirectDepsUpdated();
     const ctx = new import_evaluation_context.EvaluationContext(this.tableManager, node, node.cellAddress);
     if (node instanceof import_cell_value_node.CellValueNode && node.spillMeta) {
@@ -187,6 +443,7 @@ class EvaluationManager {
       if (spillOrigin.evaluationResult.type === "spilled-values") {
         const result = spillOrigin.evaluationResult.evaluate({ x: 0, y: 0 }, ctx);
         node.setEvaluationResult(result);
+        this.dependencyManager.registerNode(node);
         return;
       }
     }
@@ -205,6 +462,9 @@ class EvaluationManager {
         errAddress: node
       };
       node.setEvaluationResult(evaluationResult);
+      if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+        this.dependencyManager.registerNode(node);
+      }
       return;
     }
     if (typeof content !== "string" || !content.startsWith("=")) {
@@ -212,6 +472,7 @@ class EvaluationManager {
         node.setEvaluationResult({
           type: "does-not-spill"
         });
+        this.dependencyManager.registerNode(node);
         return;
       }
       const result = {
@@ -219,6 +480,9 @@ class EvaluationManager {
         result: this.convertScalarValueToCellValue(content)
       };
       node.setEvaluationResult(result);
+      if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+        this.dependencyManager.registerNode(node);
+      }
       return;
     }
     let evaluation = import_utils.captureEvaluationErrors(node, () => this.formulaEvaluator.evaluateFormula(content.slice(1), ctx));
@@ -239,11 +503,13 @@ class EvaluationManager {
       }
       if (node instanceof import_spill_meta_node.SpillMetaNode) {
         node.setEvaluationResult(evaluation);
+        this.dependencyManager.registerNode(node);
       } else {
         const spillMetaNode = this.dependencyManager.getSpillMetaNode(node.key.replace(/^[^:]+:/, "spill-meta:"));
         node.addDependency(spillMetaNode);
         node.setSpillMetaNode(spillMetaNode);
         spillMetaNode.setEvaluationResult(evaluation);
+        this.dependencyManager.registerNode(spillMetaNode);
         if (evaluation.type === "spilled-values") {
           const originResult = evaluation.evaluate({ x: 0, y: 0 }, ctx);
           node.setEvaluationResult(originResult);
@@ -251,6 +517,9 @@ class EvaluationManager {
           node.setEvaluationResult(evaluation);
         }
       }
+      if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+        this.dependencyManager.registerNode(node);
+      }
       return;
     }
     if (evaluation.type === "value") {
@@ -258,13 +527,20 @@ class EvaluationManager {
         node.setEvaluationResult({
           type: "does-not-spill"
         });
+        this.dependencyManager.registerNode(node);
         return;
       } else {
         node.setEvaluationResult(evaluation);
+        if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+          this.dependencyManager.registerNode(node);
+        }
         return;
       }
     }
     node.setEvaluationResult(evaluation);
+    if (!(node instanceof import_virtual_cell_value_node.VirtualCellValueNode)) {
+      this.dependencyManager.registerNode(node);
+    }
   }
   evaluateDependencyNode(dependency) {
     if (dependency instanceof import_empty_cell_evaluation_node.EmptyCellEvaluationNode) {
@@ -282,6 +558,9 @@ class EvaluationManager {
     if (dependency instanceof import_ast_evaluation_node.AstEvaluationNode) {
       return;
     }
+    if (dependency instanceof import_resource_dependency_node.ResourceDependencyNode) {
+      return;
+    }
     if (dependency instanceof import_spill_meta_node.SpillMetaNode) {
       this.evaluateCellNode(dependency);
       return;
@@ -318,7 +597,7 @@ class EvaluationManager {
         };
         if (evaluationPlan.cycleNodes) {
           for (const node2 of evaluationPlan.cycleNodes) {
-            if (!(node2 instanceof import_range_evaluation_node.RangeEvaluationNode)) {
+            if (!(node2 instanceof import_range_evaluation_node.RangeEvaluationNode) && !(node2 instanceof import_resource_dependency_node.ResourceDependencyNode)) {
               node2.setEvaluationResult(evaluationResult);
             }
           }
@@ -360,6 +639,12 @@ class EvaluationManager {
     this.isEvaluating = false;
   }
   convertScalarValueToCellValue(val) {
+    if (val === "INFINITY") {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (val === "-INFINITY") {
+      return { type: "infinity", sign: "negative" };
+    }
     if (typeof val === "number") {
       return { type: "number", value: val };
     }
@@ -433,4 +718,4 @@ class EvaluationManager {
   }
 }
 
-//# debugId=5440BFA176AF38B564756E2164756E21
+//# debugId=0C4138D8E8FF4A1064756E2164756E21