Add cross-sheet reference and range support

Author: jstrieb

README.md

@@ -65,6 +65,7 @@ Formulas begin with an equals sign (`=`), and can contain:
     `R-1C-1` to select the cell in the bottom right corner of the sheet, and
     `R1C0:R1C-1` to select all of row 1
 - Ranges such as `R[-3]C:R[-1]C`
+- References and ranges across sheets like `S1!R1C1` and `S[1]!R2C2:R2C-1`
 - Function calls (case insensitive) containing expressions as arguments such as
   `sum(RC0:RC[-1])`, `sLiDeR(0, 10, 1)`, and `DOLLARS(PRODUCT(1 * 2 + 3, 4, 3,
   R[-1]C))`

src/classes.svelte.js

@@ -330,7 +330,12 @@ export class Sheet {
 
         try {
           const parsed = formula.parse(cell.formula);
-          const computed = parsed.compute(this.cells, row, col);
+          const computed = parsed.compute(
+            this.globals,
+            this.globals.sheets.indexOf(this),
+            row,
+            col,
+          );
           cell.value.rederive(
             flattenArgs(computed),
             (dependencyValues, set, update) => {
@@ -387,8 +392,10 @@ export class Sheet {
         } catch (e) {
           if (!(e instanceof ParseError)) {
             cell.errorText = `Error: ${e.message}`;
+            cell.value.rederive([], (_, set) => set(undefined));
+          } else {
+            cell.value.rederive([], (_, set) => set(cell.formula));
           }
-          cell.value.rederive([], (_, set) => set(cell.formula));
         }
       });
     });

src/formula.js

@@ -21,7 +21,7 @@ class Expression {
   // Return a concrete value from an expression given the values in the other
   // rows and columns.
   /* v8 ignore next 3 */
-  compute(rows, r, c) {
+  compute(globals, sheet, r, c) {
     throw new Error("Not yet implemented");
   }
 }
@@ -60,13 +60,13 @@ class Function extends Expression {
     this.args = Array.from(args);
   }
 
-  compute(rows, r, c) {
+  compute(globals, sheet, r, c) {
     const name = this.name.toLocaleLowerCase();
     const f = functions[name];
     if (f == null) {
       throw new Error(`"${name}" is not a function`);
     }
-    const refs = this.args.map((a) => a.compute(rows, r, c));
+    const refs = this.args.map((a) => a.compute(globals, sheet, r, c));
     return new ExpressionValue(singleton(f), refs);
   }
 }
@@ -107,7 +107,7 @@ class BinaryOperation extends Expression {
     this.ast = Array.from(ast);
   }
 
-  compute(rows, r, c) {
+  compute(globals, sheet, r, c) {
     const thunk = (...args) => {
       this.ast
         .filter((x) => typeof x === "string")
@@ -121,7 +121,7 @@ class BinaryOperation extends Expression {
     };
     const refs = this.ast
       .filter((x) => x?.compute)
-      .map((x) => x.compute(rows, r, c));
+      .map((x) => x.compute(globals, sheet, r, c));
     return new ExpressionValue(undefinedArgsToIdentity(thunk), refs);
   }
 }
@@ -141,24 +141,41 @@ class UnaryOperation extends Expression {
     this.operand = operand;
   }
 
-  compute(rows, r, c) {
+  compute(globals, sheet, r, c) {
     const thunk = (x) => [this.operator(x)];
-    const refs = [this.operand.compute(rows, r, c)];
+    const refs = [this.operand.compute(globals, sheet, r, c)];
     return new ExpressionValue(undefinedArgsToIdentity(thunk), refs);
   }
 }
 
 class Ref extends Expression {
+  s;
   r;
   c;
 
-  constructor(r, c) {
+  constructor(s, r, c) {
     super();
+    this.s = s;
     this.r = r;
     this.c = c;
   }
 
-  compute(rows, r, c) {
+  compute(globals, s, r, c) {
+    let sheet;
+    if (this.s == null) {
+      sheet = s;
+    } else if (this.s.relative == null) {
+      if (this.s.absolute < 0) {
+        sheet =
+          (this.s.absolute + globals.sheets.length) % globals.sheets.length;
+      } else {
+        sheet = this.s.absolute;
+      }
+    } else {
+      sheet = s + this.s.relative;
+    }
+    const rows = globals.sheets[sheet].cells;
+
     let row;
     if (this.r == null) {
       row = r;
@@ -188,20 +205,37 @@ class Ref extends Expression {
 }
 
 class Range extends Expression {
+  s;
   r1;
   c1;
   r2;
   c2;
 
-  constructor(r1, c1, r2, c2) {
+  constructor(s, r1, c1, r2, c2) {
     super();
+    this.s = s;
     this.r1 = r1;
     this.c1 = c1;
     this.r2 = r2;
     this.c2 = c2;
   }
 
-  compute(rows, r, c) {
+  compute(globals, s, r, c) {
+    let sheet;
+    if (this.s == null) {
+      sheet = s;
+    } else if (this.s.relative == null) {
+      if (this.s.absolute < 0) {
+        sheet =
+          (this.s.absolute + globals.sheets.length) % globals.sheets.length;
+      } else {
+        sheet = this.s.absolute;
+      }
+    } else {
+      sheet = s + this.s.relative;
+    }
+    const rows = globals.sheets[sheet].cells;
+
     let startRow;
     if (this.r1 == null) {
       startRow = r;
@@ -330,12 +364,16 @@ const absNum = cellDigits.map((n) => ({ absolute: n }));
 const cellNum = relNum.or(absNum).optional();
 const r = regex(/[rR]/);
 const c = regex(/[cC]/);
+const s = regex(/[sS]/);
 
-const ref = seq(r.then(cellNum), c.then(cellNum)).map(
-  (args) => new Ref(...args),
-);
+const ref = seq(
+  s.then(cellNum).skip(str("!")).optional(),
+  r.then(cellNum),
+  c.then(cellNum),
+).map((args) => new Ref(...args));
 
 const range = seq(
+  s.then(cellNum).skip(str("!")).optional(),
   r.then(cellNum),
   c.then(cellNum).skip(lex(":")),
   r.then(cellNum),

test/sheet-and-formula.test.js

@@ -1,4 +1,4 @@
-import { State } from "../src/classes.svelte.js";
+import { Sheet, State } from "../src/classes.svelte.js";
 import { test, expect, beforeEach } from "vitest";
 import { evalCode, functions } from "../src/formula-functions.svelte.js";
 
@@ -401,3 +401,129 @@ test("Formula this object has everything it's supposed to", async () => {
   const state = createSheet([cases]);
   await expectSheet(state.currentSheet, [cases.map(() => true)]);
 });
+
+test("Cross-sheet formula references", async () => {
+  const state = createSheet([
+    [
+      "10",
+      "=S0!RC[-1]",
+      "=S[1]!R0C1",
+      "=S1!R2C2",
+      "=S[1]!R[99]C99",
+      "=S[-1]!R1C2",
+    ],
+  ]);
+  await expectSheet(state.sheets[0], [
+    [10, 10, undefined, undefined, undefined, undefined],
+  ]);
+
+  state.sheets.push(
+    new Sheet("Sheet 2", 3, 10, (i, j) => `${i * j}`, undefined, state),
+  );
+  await expectSheet(
+    state.sheets[1],
+    new Array(3)
+      .fill()
+      .map((_, i) => new Array(10).fill().map((_, j) => i * j)),
+  );
+  await expectSheet(state.sheets[0], [[10, 10, 0, 4, undefined, undefined]]);
+
+  state.sheets.unshift(
+    new Sheet(
+      "Sheet 0",
+      4,
+      4,
+      (i, j) => `=(${i} + 1) / (${j} + 1)`,
+      undefined,
+      state,
+    ),
+  );
+  await expectSheet(
+    state.sheets[0],
+    new Array(4)
+      .fill()
+      .map((_, i) => new Array(4).fill().map((_, j) => (i + 1) / (j + 1))),
+  );
+  await expectSheet(state.sheets[1], [[10, 1, 0, undefined, undefined, 2 / 3]]);
+
+  state.sheets[0].cells[0][0].formula = "=S-1!R2C5";
+  await expectSheet(
+    state.sheets[0],
+    new Array(4)
+      .fill()
+      .map((_, i) =>
+        new Array(4)
+          .fill()
+          .map((_, j) => (i == 0 && j == 0 ? 10 : (i + 1) / (j + 1))),
+      ),
+  );
+  await expectSheet(state.sheets[1], [
+    [10, 10, 0, undefined, undefined, 2 / 3],
+  ]);
+});
+
+test("Cross-sheet formula ranges", async () => {
+  const state = createSheet([
+    ["=s-1!R1C0:R1C-1", "=s0!R1C0:R1C-1", "=s!R1C0:R1C-1"],
+    ["1", "2", "3"],
+  ]);
+  await expectSheet(state.sheets[0], [
+    [
+      [1, 2, 3],
+      [1, 2, 3],
+      [1, 2, 3],
+    ],
+    [1, 2, 3],
+  ]);
+
+  state.sheets.unshift(
+    new Sheet("Sheet 0", 4, 4, (i, j) => `=${i} + ${j}`, undefined, state),
+  );
+  await expectSheet(
+    state.sheets[0],
+    new Array(4).fill().map((_, i) => new Array(4).fill().map((_, j) => i + j)),
+  );
+  await expectSheet(state.sheets[1], [
+    [
+      [1, 2, 3],
+      [1, 2, 3, 4],
+      [1, 2, 3],
+    ],
+    [1, 2, 3],
+  ]);
+
+  state.sheets.push(
+    new Sheet(
+      "Sheet 2",
+      4,
+      4,
+      (i, j) => `=(${i} + 1) * ${j}`,
+      undefined,
+      state,
+    ),
+  );
+  await expectSheet(
+    state.sheets[2],
+    new Array(4)
+      .fill()
+      .map((_, i) => new Array(4).fill().map((_, j) => (i + 1) * j)),
+  );
+  await expectSheet(state.sheets[1], [
+    [
+      [0, 2, 4, 6],
+      [1, 2, 3, 4],
+      [1, 2, 3],
+    ],
+    [1, 2, 3],
+  ]);
+
+  state.sheets[1].cells[0][0].formula = "=s[1]!R1C0:R1C-1";
+  await expectSheet(state.sheets[1], [
+    [
+      [0, 2, 4, 6],
+      [1, 2, 3, 4],
+      [1, 2, 3],
+    ],
+    [1, 2, 3],
+  ]);
+});

todo.md

@@ -84,6 +84,7 @@
 - Testing
   - Playwright
   - Integrate Playwright coverage with vitest coverage
+  - Test parsers and classes in formulas
 - Documentation
   - README
     - Description and introduction