@ricsam/formula-engine 0.0.1

package/dist/mjs/core/managers/dependency-manager.mjs

@@ -0,0 +1,593 @@
+// src/core/managers/dependency-manager.ts
+import {
+  eligibleKeysForContext,
+  getContextDependencyKey
+} from "src/evaluator/evaluation-context";
+import { isCellInRange, keyToCellAddress } from "../utils.mjs";
+import { AstEvaluationNode } from "src/evaluator/dependency-nodes/ast-evaluation-node";
+import { CellValueNode } from "src/evaluator/dependency-nodes/cell-value-node";
+import { EmptyCellEvaluationNode } from "src/evaluator/dependency-nodes/empty-cell-evaluation-node";
+import { RangeEvaluationNode } from "src/evaluator/range-evaluation-node";
+import { astToString } from "src/parser/formatter";
+import { SpillMetaNode } from "src/evaluator/dependency-nodes/spill-meta-node";
+
+class DependencyManager {
+  cacheManager;
+  workbookManager;
+  evaluatedNodes = new Map;
+  spillMetaNodes = new Map;
+  emptyCells = new Map;
+  _spilledValues = new Map;
+  ranges = new Map;
+  constructor(cacheManager, workbookManager) {
+    this.cacheManager = cacheManager;
+    this.workbookManager = workbookManager;
+  }
+  get spilledValues() {
+    return this._spilledValues.values();
+  }
+  isSpillOrigin(cellAddress) {
+    for (const spilledValue of this._spilledValues.values()) {
+      if (spilledValue.origin.sheetName !== cellAddress.sheetName || spilledValue.origin.workbookName !== cellAddress.workbookName) {
+        continue;
+      }
+      if (spilledValue.origin.colIndex === cellAddress.colIndex && spilledValue.origin.rowIndex === cellAddress.rowIndex) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getSpillValue(cellAddress) {
+    for (const spilledValue of this._spilledValues.values()) {
+      if (spilledValue.origin.sheetName !== cellAddress.sheetName || spilledValue.origin.workbookName !== cellAddress.workbookName) {
+        continue;
+      }
+      if (spilledValue.origin.colIndex === cellAddress.colIndex && spilledValue.origin.rowIndex === cellAddress.rowIndex) {
+        return;
+      }
+      if (isCellInRange(cellAddress, spilledValue.spillOnto)) {
+        return spilledValue;
+      }
+    }
+    return;
+  }
+  getSpilledAddress(cellAddress, passedSpilledValue) {
+    const spilledValue = passedSpilledValue ?? this.getSpillValue(cellAddress);
+    if (!spilledValue) {
+      throw new Error("Cell is not spilled");
+    }
+    const offsetLeft = cellAddress.colIndex - spilledValue.origin.colIndex;
+    const offsetTop = cellAddress.rowIndex - spilledValue.origin.rowIndex;
+    const address = {
+      ...cellAddress,
+      colIndex: spilledValue.origin.colIndex + offsetLeft,
+      rowIndex: spilledValue.origin.rowIndex + offsetTop
+    };
+    if (offsetLeft === 0 && offsetTop === 0) {
+      throw new Error("Spilled value is the same as the cell address! The origin has a pre-calculated value that can be used");
+    }
+    return { address, spillOffset: { x: offsetLeft, y: offsetTop } };
+  }
+  clearEvaluationCache() {
+    this.cacheManager.clear();
+    this.evaluatedNodes.clear();
+    this.emptyCells.clear();
+    this.asts.clear();
+    this.spillMetaNodes.clear();
+    this.ranges.clear();
+    this._spilledValues.clear();
+  }
+  setSpilledValue(nodeKey, spilledValue) {
+    this._spilledValues.set(nodeKey.replace(/^[^:]+:/, ""), spilledValue);
+  }
+  getSpilledValue(nodeKey) {
+    return this._spilledValues.get(nodeKey.replace(/^[^:]+:/, ""));
+  }
+  getEmptyCellNode(nodeKey) {
+    if (!nodeKey.startsWith("empty:")) {
+      throw new Error("Invalid empty cell node key: " + nodeKey);
+    }
+    if (!this.emptyCells.has(nodeKey)) {
+      const node = new EmptyCellEvaluationNode(nodeKey, this, this.workbookManager);
+      this.emptyCells.set(nodeKey, node);
+      return node;
+    }
+    return this.emptyCells.get(nodeKey);
+  }
+  getSpillMetaNode(nodeKey) {
+    if (!nodeKey.startsWith("spill-meta:")) {
+      throw new Error("Invalid spill meta node key: " + nodeKey);
+    }
+    if (!this.spillMetaNodes.has(nodeKey)) {
+      const node = new SpillMetaNode(nodeKey);
+      this.spillMetaNodes.set(nodeKey, node);
+      return node;
+    }
+    return this.spillMetaNodes.get(nodeKey);
+  }
+  getCellValueNode(nodeKey) {
+    if (!nodeKey.startsWith("cell-value:")) {
+      throw new Error("Invalid cell value node key: " + nodeKey);
+    }
+    if (!this.evaluatedNodes.has(nodeKey)) {
+      const node = new CellValueNode(nodeKey);
+      this.evaluatedNodes.set(nodeKey, node);
+      return node;
+    }
+    return this.evaluatedNodes.get(nodeKey);
+  }
+  getCellValueOrEmptyCellNode(nodeKey) {
+    const cellAddress = keyToCellAddress(nodeKey);
+    const emptyKey = nodeKey.replace(/^[^:]+:/, "empty:");
+    const cellValueKey = nodeKey.replace(/^[^:]+:/, "cell-value:");
+    if (this.workbookManager.isCellEmpty(cellAddress)) {
+      return this.getEmptyCellNode(emptyKey);
+    }
+    return this.getCellValueNode(cellValueKey);
+  }
+  getSpillMetaOrEmptySpillMetaNode(nodeKey) {
+    const cellAddress = keyToCellAddress(nodeKey);
+    const emptyKey = nodeKey.replace(/^[^:]+:/, "empty:");
+    const spillMetaKey = nodeKey.replace(/^[^:]+:/, "spill-meta:");
+    if (this.workbookManager.isCellEmpty(cellAddress)) {
+      return this.getEmptyCellNode(emptyKey);
+    }
+    return this.getSpillMetaNode(spillMetaKey);
+  }
+  lookupCellNode(nodeKey, types) {
+    const cellAddress = keyToCellAddress(nodeKey);
+    const emptyKey = nodeKey.replace(/^[^:]+:/, "empty:");
+    const cellValueKey = nodeKey.replace(/^[^:]+:/, "cell-value:");
+    const cellValueNode = this.evaluatedNodes.get(cellValueKey);
+    const cellMetaKey = nodeKey.replace(/^[^:]+:/, "cell-meta:");
+    const cellMetaNode = this.evaluatedNodes.get(cellMetaKey);
+    if (this.workbookManager.isCellEmpty(cellAddress)) {
+      if (types.includes("empty")) {
+        return [this.getEmptyCellNode(emptyKey)];
+      } else {
+        return [];
+      }
+    }
+    const results = [];
+    if (types.includes("cell")) {
+      if (cellValueNode) {
+        results.push(cellValueNode);
+      } else {
+        results.push(this.getCellValueNode(cellValueKey));
+      }
+    }
+    if (this.workbookManager.isFormulaCell(cellAddress)) {
+      if (types.includes("spill-meta")) {
+        if (cellMetaNode) {
+          results.push(cellMetaNode);
+        } else {
+          results.push(this.getSpillMetaNode(cellValueKey));
+        }
+      }
+    }
+    return results;
+  }
+  getRangeNode(rangeKey) {
+    if (!rangeKey.startsWith("range:")) {
+      throw new Error("Invalid range node key: " + rangeKey);
+    }
+    if (!this.ranges.has(rangeKey)) {
+      const node = new RangeEvaluationNode(rangeKey, this, this.workbookManager);
+      this.ranges.set(rangeKey, node);
+      return node;
+    }
+    return this.ranges.get(rangeKey);
+  }
+  asts = new Map;
+  getAstNode(ast, currentContext) {
+    const astKey = `ast:${astToString(ast)}`;
+    const astEntries = this.asts.get(astKey);
+    const keys = eligibleKeysForContext(currentContext);
+    for (const key of keys) {
+      const astEntry = astEntries?.entries.get(key);
+      if (astEntry) {
+        return astEntry.evalNode;
+      }
+    }
+    const node = new AstEvaluationNode(ast, currentContext);
+    this.saveAstNode(node, currentContext);
+    return node;
+  }
+  saveAstNode(ast, contextDependency) {
+    const astKey = ast.key;
+    const contextDependencyKey = getContextDependencyKey(contextDependency);
+    const astEntries = this.asts.get(astKey);
+    if (astEntries) {
+      astEntries.entries.set(contextDependencyKey, {
+        evalNode: ast,
+        contextDependency
+      });
+    } else {
+      this.asts.set(astKey, {
+        entries: new Map([
+          [contextDependencyKey, { evalNode: ast, contextDependency }]
+        ])
+      });
+    }
+  }
+  getEvaluatedNodes() {
+    return this.evaluatedNodes;
+  }
+  getTransitiveDepsForEvalOrder(node, visited = new Set) {
+    if (visited.has(node)) {
+      return new Set;
+    }
+    if (node && node.resolved) {
+      return new Set;
+    }
+    visited.add(node);
+    const allNodes = new Set;
+    allNodes.add(node);
+    const directDeps = node.getDependencies();
+    for (const dep of directDeps) {
+      if (!visited.has(dep)) {
+        const depTransitiveDeps = this.getTransitiveDepsForEvalOrder(dep, visited);
+        for (const transitiveDep of depTransitiveDeps) {
+          allNodes.add(transitiveDep);
+        }
+      }
+    }
+    visited.delete(node);
+    return allNodes;
+  }
+  buildEvaluationOrder(node) {
+    if (node.resolved && this.cacheManager.getEvaluationOrder(node.key)) {
+      return this.cacheManager.getEvaluationOrder(node.key);
+    }
+    const allNodes = new Map;
+    const visitedForDiscovery = new Set;
+    const discoverNodes = (currentNode) => {
+      if (currentNode && currentNode.resolved) {
+        return;
+      }
+      if (!allNodes.has(currentNode.key)) {
+        allNodes.set(currentNode.key, currentNode);
+      }
+      if (visitedForDiscovery.has(currentNode)) {
+        return;
+      }
+      visitedForDiscovery.add(currentNode);
+      const allDeps = currentNode.getAllDependencies();
+      for (const dep of allDeps) {
+        discoverNodes(dep);
+      }
+    };
+    discoverNodes(node);
+    if (allNodes.size === 0 && node && node.resolved) {
+      const result2 = {
+        evaluationOrder: new Set([node]),
+        hasCycle: false,
+        hash: this.computeHash(new Set([node]))
+      };
+      if (node && node.resolved) {
+        this.cacheManager.setEvaluationOrder(node.key, result2);
+      }
+      return result2;
+    }
+    const sccs = this.findSCCs(allNodes, true);
+    const nodeToSCCId = new Map;
+    const sccList = [];
+    for (let i = 0;i < sccs.length; i++) {
+      const sccNodes = sccs[i];
+      const allResolved = Array.from(sccNodes).every((n) => n.resolved);
+      const sccHash = Array.from(sccNodes).map((n) => n.key).sort().join("|");
+      let scc;
+      const cachedSCC = allResolved ? this.cacheManager.getSCC(sccHash) : undefined;
+      if (cachedSCC) {
+        scc = cachedSCC;
+      } else {
+        const sccEvalOrder = this.buildSCCEvaluationOrder(sccNodes);
+        const hardEdgeSCCs = this.findSCCs(new Map(Array.from(sccNodes).map((n) => [n.key, n])), false);
+        scc = {
+          id: i,
+          nodes: sccNodes,
+          evaluationOrder: sccEvalOrder,
+          resolved: allResolved,
+          hardEdgeSCCs
+        };
+        if (allResolved) {
+          this.cacheManager.setSCC(sccHash, scc);
+        }
+      }
+      sccList.push(scc);
+      for (const n of sccNodes) {
+        nodeToSCCId.set(n, i);
+      }
+    }
+    const sccGraph = new Map;
+    for (let i = 0;i < sccList.length; i++) {
+      sccGraph.set(i, new Set);
+    }
+    for (const [_, n] of allNodes) {
+      const nSCCId = nodeToSCCId.get(n);
+      const deps = n.getAllDependencies();
+      for (const dep of deps) {
+        if (!allNodes.has(dep.key))
+          continue;
+        const depSCCId = nodeToSCCId.get(dep);
+        if (nSCCId !== depSCCId) {
+          sccGraph.get(depSCCId).add(nSCCId);
+        }
+      }
+    }
+    const inDegree = new Map;
+    for (let i = 0;i < sccList.length; i++) {
+      inDegree.set(i, 0);
+    }
+    for (const [_, deps] of sccGraph) {
+      for (const toId of deps) {
+        inDegree.set(toId, inDegree.get(toId) + 1);
+      }
+    }
+    const queue = [];
+    for (let i = 0;i < sccList.length; i++) {
+      if (inDegree.get(i) === 0) {
+        queue.push(i);
+      }
+    }
+    const sortedSCCIds = [];
+    while (queue.length > 0) {
+      const sccId = queue.shift();
+      sortedSCCIds.push(sccId);
+      const deps = sccGraph.get(sccId);
+      for (const depId of deps) {
+        const newInDegree = inDegree.get(depId) - 1;
+        inDegree.set(depId, newInDegree);
+        if (newInDegree === 0) {
+          queue.push(depId);
+        }
+      }
+    }
+    const evaluationOrderArray = [];
+    for (const sccId of sortedSCCIds) {
+      const scc = sccList[sccId];
+      evaluationOrderArray.push(...scc.evaluationOrder);
+    }
+    const evaluationOrder = new Set(evaluationOrderArray);
+    const cycleNodes = new Set;
+    for (const scc of sccList) {
+      for (const hardEdgeSCC of scc.hardEdgeSCCs) {
+        if (hardEdgeSCC.size > 1) {
+          for (const n of hardEdgeSCC) {
+            cycleNodes.add(n);
+          }
+        } else if (hardEdgeSCC.size === 1) {
+          const node2 = Array.from(hardEdgeSCC)[0];
+          if (node2.getDependencies().has(node2)) {
+            cycleNodes.add(node2);
+          }
+        }
+      }
+    }
+    const hasCycle = cycleNodes.size > 0;
+    const result = {
+      evaluationOrder,
+      hasCycle,
+      ...hasCycle && { cycleNodes },
+      hash: this.computeGraphHash(allNodes, sccList),
+      sccDAG: {
+        sccList,
+        sccGraph
+      }
+    };
+    if (node && node.resolved) {
+      this.cacheManager.setEvaluationOrder(node.key, result);
+    }
+    return result;
+  }
+  findSCCs(nodes, includeFrontier) {
+    const index = new Map;
+    const lowlink = new Map;
+    const onStack = new Set;
+    const stack = [];
+    const sccs = [];
+    let currentIndex = 0;
+    const strongConnect = (v) => {
+      index.set(v, currentIndex);
+      lowlink.set(v, currentIndex);
+      currentIndex++;
+      stack.push(v);
+      onStack.add(v);
+      const successors = includeFrontier ? v.getAllDependencies() : v.getDependencies();
+      for (const w of successors) {
+        if (!nodes.has(w.key)) {
+          continue;
+        }
+        if (!index.has(w)) {
+          strongConnect(w);
+          lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+        } else if (onStack.has(w)) {
+          lowlink.set(v, Math.min(lowlink.get(v), index.get(w)));
+        }
+      }
+      if (lowlink.get(v) === index.get(v)) {
+        const scc = new Set;
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.add(w);
+        } while (w !== v);
+        sccs.push(scc);
+      }
+    };
+    for (const [_, n] of nodes) {
+      if (!index.has(n)) {
+        strongConnect(n);
+      }
+    }
+    return sccs;
+  }
+  buildSCCEvaluationOrder(sccNodes) {
+    const visited = new Set;
+    const visiting = new Set;
+    const result = [];
+    const dfs = (n) => {
+      if (visited.has(n)) {
+        return;
+      }
+      if (visiting.has(n)) {
+        return;
+      }
+      visiting.add(n);
+      const deps = n.getAllDependencies();
+      for (const dep of deps) {
+        if (sccNodes.has(dep) && !visited.has(dep)) {
+          dfs(dep);
+        }
+      }
+      visiting.delete(n);
+      visited.add(n);
+      result.push(n);
+    };
+    const sortedNodes = Array.from(sccNodes).sort((a, b) => a.key.localeCompare(b.key));
+    for (const n of sortedNodes) {
+      if (!visited.has(n)) {
+        dfs(n);
+      }
+    }
+    return result;
+  }
+  computeGraphHash(allNodes, sccList) {
+    const parts = [];
+    for (const [key, node] of Array.from(allNodes.entries()).sort()) {
+      const deps = Array.from(node.getAllDependencies()).map((d) => d.key).sort().join(",");
+      parts.push(`${key}:[${deps}]`);
+    }
+    for (const scc of sccList) {
+      const nodeKeys = Array.from(scc.nodes).map((n) => n.key).sort().join(",");
+      parts.push(`SCC${scc.id}:{${nodeKeys}}`);
+    }
+    return parts.join("|");
+  }
+  computeHash(allNodes) {
+    const nodeStates = [];
+    for (const node of Array.from(allNodes).sort()) {
+      if (node) {
+        const deps = Array.from(node.getDependencies() || []).map((dep) => dep.key).sort().join(",");
+        const frontierDeps = Array.from(node.getFrontierDependencies()).map((dep) => dep.key).sort().join(";");
+        const nodeState = `${node.key}:{deps:[${deps}],frontier:[${frontierDeps}]}`;
+        nodeStates.push(nodeState);
+      }
+    }
+    return nodeStates.join("|");
+  }
+  getDependencyTree(node) {
+    const visited = new Set;
+    const nodeToType = (node2) => {
+      if (node2 instanceof RangeEvaluationNode) {
+        return "range";
+      }
+      if (node2 instanceof EmptyCellEvaluationNode) {
+        return "empty";
+      }
+      return "cell";
+    };
+    const buildTree = (node2, isSelf = false) => {
+      const cellRef = node2.toString();
+      if (isSelf) {
+        return {
+          type: nodeToType(node2),
+          resultType: node2 instanceof RangeEvaluationNode ? "range" : node2.evaluationResult ? node2.evaluationResult.type : "awaiting-evaluation",
+          canResolve: node2.canResolve(),
+          key: cellRef,
+          directDepsUpdated: node2.directDepsUpdated,
+          resolved: node2.resolved,
+          self: true,
+          circular: true
+        };
+      }
+      if (visited.has(node2)) {
+        return {
+          type: nodeToType(node2),
+          resultType: node2 instanceof RangeEvaluationNode ? "range" : node2.evaluationResult ? node2.evaluationResult.type : "awaiting-evaluation",
+          canResolve: node2.canResolve(),
+          key: cellRef,
+          directDepsUpdated: node2.directDepsUpdated,
+          resolved: node2.resolved,
+          circular: true
+        };
+      }
+      visited.add(node2);
+      const directDeps = Array.from(node2.getDependencies());
+      let frontierDeps = Array.from(node2.getFrontierDependencies());
+      const deps = directDeps.map((dep) => buildTree(dep, dep.key === node2.key));
+      const frontierDependencies = frontierDeps.map((dep) => buildTree(dep, false));
+      visited.delete(node2);
+      const result = {
+        type: nodeToType(node2),
+        resultType: node2 instanceof RangeEvaluationNode ? "range" : node2.evaluationResult ? node2.evaluationResult.type : "awaiting-evaluation",
+        canResolve: node2.canResolve(),
+        key: cellRef,
+        directDepsUpdated: node2.directDepsUpdated,
+        resolved: node2.resolved
+      };
+      if (deps.length > 0) {
+        result.deps = deps;
+      }
+      if (frontierDependencies.length > 0) {
+        result.frontierDependencies = frontierDependencies;
+      }
+      return result;
+    };
+    return buildTree(node);
+  }
+  markResolvedNodes(node) {
+    const visited = new Set;
+    visited.add(node);
+    const areTransitiveDepsResolved = (nodes) => {
+      let canResolve = true;
+      for (const node2 of nodes) {
+        if (visited.has(node2) || node2.resolved) {
+          continue;
+        }
+        visited.add(node2);
+        const directDeps = node2.getDependencies();
+        const a = areTransitiveDepsResolved(directDeps);
+        const b = node2.canResolve();
+        if (!a || !b) {
+          canResolve = false;
+        }
+        if (a && b) {
+          node2.resolve();
+          if (node2 instanceof AstEvaluationNode) {
+            this.saveAstNode(node2, node2.getContextDependency());
+          }
+        }
+      }
+      return canResolve;
+    };
+    if (areTransitiveDepsResolved(node.getDependencies()) && node.canResolve()) {
+      node.resolve();
+      if (node instanceof AstEvaluationNode) {
+        this.saveAstNode(node, node.getContextDependency());
+      }
+    }
+  }
+  updateResolvedSCCs(evalOrder) {
+    if (!evalOrder.sccDAG) {
+      return;
+    }
+    for (const scc of evalOrder.sccDAG.sccList) {
+      const allResolved = Array.from(scc.nodes).every((n) => n.resolved);
+      if (allResolved && !scc.resolved) {
+        const updatedSCC = {
+          ...scc,
+          resolved: true
+        };
+        const sccHash = Array.from(scc.nodes).map((n) => n.key).sort().join("|");
+        this.cacheManager.setSCC(sccHash, updatedSCC);
+      }
+    }
+  }
+}
+export {
+  DependencyManager
+};
+
+//# debugId=D496BB6F54AC889364756E2164756E21