@lotics/xlsx 0.1.0

package/src/formula_engine.test.ts

@@ -0,0 +1,348 @@
+import { DependencyGraph } from "./formula_deps";
+import { FormulaEngine, recomputeAll, recomputeIfStale } from "./formula_engine";
+import { WorkbookModel, SheetModel, StyleRegistry } from "./workbook_model";
+
+// =============================================================================
+// DependencyGraph
+// =============================================================================
+
+describe("DependencyGraph", () => {
+  test("tracks direct dependents", () => {
+    const g = new DependencyGraph();
+    // B1 depends on A1
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    expect(g.getDirectDependents("Sheet1!A1")).toEqual(["Sheet1!B1"]);
+  });
+
+  test("tracks multiple dependents", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.setDependencies("Sheet1!C1", ["Sheet1!A1"]);
+    const deps = g.getDirectDependents("Sheet1!A1");
+    expect(deps).toHaveLength(2);
+    expect(deps).toContain("Sheet1!B1");
+    expect(deps).toContain("Sheet1!C1");
+  });
+
+  test("removeCell cleans up edges", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.removeCell("Sheet1!B1");
+    expect(g.getDirectDependents("Sheet1!A1")).toEqual([]);
+  });
+
+  test("setDependencies replaces old edges", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.setDependencies("Sheet1!B1", ["Sheet1!C1"]);
+    expect(g.getDirectDependents("Sheet1!A1")).toEqual([]);
+    expect(g.getDirectDependents("Sheet1!C1")).toEqual(["Sheet1!B1"]);
+  });
+
+  test("getRecalcOrder returns topological order", () => {
+    const g = new DependencyGraph();
+    // A1 → B1 → C1 (C1 depends on B1 which depends on A1)
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.setDependencies("Sheet1!C1", ["Sheet1!B1"]);
+
+    const order = g.getRecalcOrder(["Sheet1!A1"]);
+    expect(order).toEqual(["Sheet1!B1", "Sheet1!C1"]);
+  });
+
+  test("getRecalcOrder handles diamond dependencies", () => {
+    const g = new DependencyGraph();
+    // A1 → B1, A1 → C1, B1 → D1, C1 → D1
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.setDependencies("Sheet1!C1", ["Sheet1!A1"]);
+    g.setDependencies("Sheet1!D1", ["Sheet1!B1", "Sheet1!C1"]);
+
+    const order = g.getRecalcOrder(["Sheet1!A1"]);
+    expect(order).toHaveLength(3);
+    // D1 must come after both B1 and C1
+    expect(order.indexOf("Sheet1!D1")).toBeGreaterThan(order.indexOf("Sheet1!B1"));
+    expect(order.indexOf("Sheet1!D1")).toBeGreaterThan(order.indexOf("Sheet1!C1"));
+  });
+
+  test("getRecalcOrder returns empty for no dependents", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    expect(g.getRecalcOrder(["Sheet1!C1"])).toEqual([]);
+  });
+
+  test("detectCycle finds simple cycle", () => {
+    const g = new DependencyGraph();
+    // A1 → B1 → A1 (circular)
+    g.setDependencies("Sheet1!A1", ["Sheet1!B1"]);
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+
+    const cycle = g.detectCycle("Sheet1!A1");
+    expect(cycle).not.toBeNull();
+    expect(cycle).toContain("Sheet1!A1");
+  });
+
+  test("detectCycle returns null for no cycle", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    expect(g.detectCycle("Sheet1!B1")).toBeNull();
+  });
+
+  test("clear resets the graph", () => {
+    const g = new DependencyGraph();
+    g.setDependencies("Sheet1!B1", ["Sheet1!A1"]);
+    g.clear();
+    expect(g.size).toBe(0);
+    expect(g.getDirectDependents("Sheet1!A1")).toEqual([]);
+  });
+});
+
+// =============================================================================
+// FormulaEngine integration
+// =============================================================================
+
+function makeWorkbook(): WorkbookModel {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Sheet1");
+  return new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+}
+
+describe("FormulaEngine", () => {
+  test("evaluates SUM formula", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 10);
+    sheet.set("A2", 20);
+    sheet.set("A3", null, undefined, undefined, "SUM(A1:A2)");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing();
+
+    expect(sheet.getCell("A3")?.value).toBe(30);
+    expect(sheet.getCell("A3")?.displayValue).toBe("30");
+  });
+
+  test("evaluates IF formula", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 10);
+    sheet.set("B1", null, undefined, undefined, 'IF(A1>5,"big","small")');
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing();
+
+    expect(sheet.getCell("B1")?.value).toBe("big");
+  });
+
+  test("recalculates dependents on cell change", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 10);
+    sheet.set("B1", null, undefined, undefined, "A1*2");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing();
+
+    expect(sheet.getCell("B1")?.value).toBe(20);
+
+    // Change A1
+    sheet.set("A1", 50);
+    engine.onCellChanged("Sheet1", "A1");
+
+    expect(sheet.getCell("B1")?.value).toBe(100);
+  });
+
+  test("builds dependency graph from formula cells", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 1);
+    sheet.set("A2", 2);
+    sheet.set("A3", null, undefined, undefined, "SUM(A1:A2)");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+
+    expect(engine.deps.size).toBeGreaterThan(0);
+  });
+
+  test("handles formula errors gracefully", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", null, undefined, undefined, "1/0");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing();
+
+    // Should not throw. fast-formula-parser returns #DIV/0! FormulaError for 1/0.
+    const cell = sheet.getCell("A1");
+    expect(cell).toBeDefined();
+    expect(cell?.error).toBe("#DIV/0!");
+    expect(cell?.displayValue).toBe("#DIV/0!");
+  });
+
+  test("chain recalculation: A1 → B1 → C1", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 5);
+    sheet.set("B1", null, undefined, undefined, "A1+10");
+    sheet.set("C1", null, undefined, undefined, "B1*2");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing();
+
+    expect(sheet.getCell("B1")?.value).toBe(15);
+    expect(sheet.getCell("C1")?.value).toBe(30);
+
+    // Change A1
+    sheet.set("A1", 100);
+    engine.onCellChanged("Sheet1", "A1");
+
+    expect(sheet.getCell("B1")?.value).toBe(110);
+    expect(sheet.getCell("C1")?.value).toBe(220);
+  });
+
+  test("new formula cell gets dependency tracking", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 10);
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+
+    // Add a new formula
+    sheet.set("B1", null, undefined, undefined, "A1+5");
+    engine.onCellChanged("Sheet1", "B1", "A1+5");
+
+    expect(sheet.getCell("B1")?.value).toBe(15);
+
+    // Change A1 — B1 should recalculate
+    sheet.set("A1", 20);
+    engine.onCellChanged("Sheet1", "A1");
+
+    expect(sheet.getCell("B1")?.value).toBe(25);
+  });
+
+  test("preserves cached values for cells with values", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    // Cell with both a formula and a cached value
+    sheet.set("A1", 10);
+    sheet.set("B1", 42, undefined, undefined, "A1+32");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateMissing(); // Should NOT re-evaluate B1 since it has a cached value
+
+    // B1 should keep its cached value
+    expect(sheet.getCell("B1")?.value).toBe(42);
+  });
+
+  test("evaluateAll overwrites stale cached values — template-generation case", () => {
+    // Regression: template placeholder substitution rewrites the cells a
+    // formula references but leaves the formula's own `<v>` cache
+    // untouched. Real Excel recomputes on open; our renderer trusts the
+    // cache and shows the stale value (often a zero rendered via the
+    // zero-section of the numFmt, e.g. `"-"`). evaluateAll brings every
+    // formula back into sync with current cell values.
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 100);
+    sheet.set("A2", 200);
+    // Stale cache: the formula reads A1+A2 (=300) but the writer left an
+    // old value from a different input set.
+    sheet.set("B1", 0, undefined, undefined, "A1+A2");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateAll();
+
+    expect(sheet.getCell("B1")?.value).toBe(300);
+  });
+
+  test("recomputeAll always overwrites cached values", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 10);
+    wb.sheets[0].set("B1", 99, undefined, undefined, "A1*2");
+
+    // No flag needed — recomputeAll is unconditional.
+    recomputeAll(wb);
+    expect(wb.sheets[0].getCell("B1")?.value).toBe(20);
+  });
+
+  test("recomputeIfStale fires iff workbook.fullCalcOnLoad is set", () => {
+    // No flag → cached stale value preserved (engine never runs).
+    const wbA = makeWorkbook();
+    wbA.sheets[0].set("A1", 10);
+    wbA.sheets[0].set("B1", 99, undefined, undefined, "A1*2");
+    wbA.fullCalcOnLoad = false;
+    recomputeIfStale(wbA);
+    expect(wbA.sheets[0].getCell("B1")?.value).toBe(99);
+
+    // Flag set → cached value overwritten by live computation.
+    const wbB = makeWorkbook();
+    wbB.sheets[0].set("A1", 10);
+    wbB.sheets[0].set("B1", 99, undefined, undefined, "A1*2");
+    wbB.fullCalcOnLoad = true;
+    recomputeIfStale(wbB);
+    expect(wbB.sheets[0].getCell("B1")?.value).toBe(20);
+  });
+
+  test("evaluateAll recomputes SUM over numeric cells after range expansion", () => {
+    // Matches the VN báo giá pipeline: template row `SUM(H8:H8)` is copied
+    // to `SUM(H19:H19)` when the items loop expands, then the data cells
+    // get numeric values from the agent's payload. The formula's cached
+    // value stays `0` until someone evaluates it.
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("H19", 15425000);
+    sheet.set("H20", 0, undefined, undefined, "SUM(H19:H19)");
+
+    const engine = new FormulaEngine(wb);
+    engine.buildGraph();
+    engine.evaluateAll();
+
+    expect(sheet.getCell("H20")?.value).toBe(15425000);
+  });
+
+  test("evaluateExpression resolves cell references", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("C5", 999);
+
+    const engine = new FormulaEngine(wb);
+    const result = engine.evaluateExpression("C5+1", "Sheet1", 1, 1);
+    expect(result).toBe(1000);
+  });
+
+  test("evaluateExpression handles SUM over range", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 10);
+    sheet.set("A2", 20);
+    sheet.set("A3", 30);
+
+    const engine = new FormulaEngine(wb);
+    const result = engine.evaluateExpression("SUM(A1:A3)", "Sheet1", 1, 1);
+    expect(result).toBe(60);
+  });
+
+  test("evaluateExpression returns formula result", () => {
+    const wb = makeWorkbook();
+    const sheet = wb.sheets[0];
+    sheet.set("A1", 150);
+
+    const engine = new FormulaEngine(wb);
+    const result = engine.evaluateExpression("A1>100", "Sheet1", 1, 1);
+    expect(result).toBe(true);
+  });
+
+  test("evaluateExpression returns null for errors", () => {
+    const wb = makeWorkbook();
+    const engine = new FormulaEngine(wb);
+    const result = engine.evaluateExpression("NONEXISTENT()", "Sheet1", 1, 1);
+    expect(result).toBeNull();
+  });
+});