@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/tests/plugins/edition_test.ts

@@ -0,0 +1,100 @@
+import { toZone } from "../../src/helpers";
+import { Model } from "../../src/model";
+import "../helpers"; // to have getcontext mocks
+import { getCell } from "../helpers";
+
+describe("edition", () => {
+  test("adding and removing a cell (by setting its content to empty string", () => {
+    const model = new Model();
+    // adding
+    model.dispatch("START_EDITION", { text: "a" });
+    model.dispatch("STOP_EDITION");
+    expect(Object.keys(model["workbook"].activeSheet.cells)).toEqual(["A1"]);
+    expect(model["workbook"].activeSheet.cells["A1"].content).toBe("a");
+
+    // removing
+    model.dispatch("START_EDITION");
+    model.dispatch("SET_CURRENT_CONTENT", { content: "" });
+    model.dispatch("STOP_EDITION");
+    expect(model["workbook"].activeSheet.cells).toEqual({});
+  });
+
+  test("deleting a cell with style does not remove it", () => {
+    const model = new Model({
+      sheets: [
+        {
+          colNumber: 10,
+          rowNumber: 10,
+          cells: { A2: { style: 1, content: "a2" } },
+        },
+      ],
+      styles: {
+        1: { fillColor: "red" },
+      },
+    });
+
+    // removing
+    expect(model["workbook"].activeSheet.cells["A2"].content).toBe("a2");
+    model.dispatch("SELECT_CELL", { col: 0, row: 1 });
+    model.dispatch("DELETE_CONTENT", {
+      sheet: model.getters.getActiveSheet(),
+      target: model.getters.getSelectedZones(),
+    });
+    expect("A2" in model["workbook"].activeSheet.cells).toBeTruthy();
+    expect(model["workbook"].activeSheet.cells["A2"].content).toBe("");
+  });
+
+  test("editing a cell, then activating a new sheet: edition should be stopped", () => {
+    const model = new Model();
+    const sheet1 = model["workbook"].visibleSheets[0];
+    model.dispatch("START_EDITION", { text: "a" });
+    expect(model.getters.getEditionMode()).toBe("editing");
+    model.dispatch("CREATE_SHEET", { activate: true, id: "42" });
+    expect(model.getters.getEditionMode()).toBe("inactive");
+    expect(getCell(model, "A1")).toBe(null);
+    model.dispatch("ACTIVATE_SHEET", { from: model.getters.getActiveSheet(), to: sheet1 });
+    expect(getCell(model, "A1")!.content).toBe("a");
+  });
+
+  test("editing a cell, start a composer selection, then activating a new sheet: mode should still be selecting", () => {
+    const model = new Model();
+    const sheet1 = model["workbook"].visibleSheets[0];
+    model.dispatch("START_EDITION", { text: "=" });
+    model.dispatch("START_COMPOSER_SELECTION");
+    expect(model.getters.getEditionMode()).toBe("selecting");
+    expect(model.getters.getEditionSheet()).toBe(sheet1);
+    model.dispatch("CREATE_SHEET", { activate: true, id: "42", name: "Sheet2" });
+    expect(model.getters.getEditionMode()).toBe("selecting");
+    expect(model.getters.getEditionSheet()).toBe(sheet1);
+    model.dispatch("STOP_EDITION");
+    expect(getCell(model, "A1", model.getters.getActiveSheet())).toBeNull();
+    model.dispatch("ACTIVATE_SHEET", { from: model.getters.getActiveSheet(), to: sheet1 });
+    expect(getCell(model, "A1")!.content).toBe("=");
+  });
+
+  test("ignore stopping composer selection if not selecting", () => {
+    const model = new Model();
+    expect(model.getters.getEditionMode()).toBe("inactive");
+    model.dispatch("STOP_COMPOSER_SELECTION");
+    expect(model.getters.getEditionMode()).toBe("inactive");
+  });
+
+  test("start editing where theres a merge on other sheet, change sheet, and stop edition", () => {
+    const model = new Model();
+    const sheetId1 = model.getters.getActiveSheet();
+    const sheetId2 = "42";
+    model.dispatch("ADD_MERGE", {
+      sheet: sheetId1,
+      zone: toZone("A1:D5"),
+    });
+    model.dispatch("CREATE_SHEET", { activate: true, id: sheetId2 });
+    model.dispatch("SELECT_CELL", { col: 2, row: 2 });
+
+    model.dispatch("START_EDITION", { text: "=" });
+    model.dispatch("START_COMPOSER_SELECTION");
+    model.dispatch("ACTIVATE_SHEET", { from: sheetId2, to: sheetId1 });
+    model.dispatch("STOP_EDITION");
+    expect(model.getters.getCell(2, 2, "Sheet2")?.content).toBe("=");
+    expect(model.getters.getCell(0, 0, "Sheet2")).toBeNull();
+  });
+});

package/tests/plugins/evaluation_async_test.ts

@@ -0,0 +1,332 @@
+import { args, functionRegistry } from "../../src/functions";
+import { toCartesian } from "../../src/helpers";
+import { Model } from "../../src/model";
+import { LOADING } from "../../src/plugins/evaluation";
+import { asyncComputations, patch, waitForRecompute } from "../helpers";
+
+describe("evaluateCells, async formulas", () => {
+  test("async formula", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=3" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=WAIT(3)" });
+    model.dispatch("SET_VALUE", { xc: "A3", text: "= WAIT(1) + 1" });
+
+    expect(model.getters.getCell(0, 0)!.formula!.compiledFormula.async).toBe(false);
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(0, 2)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(2);
+    await waitForRecompute();
+    expect(model.getters.getCell(0, 1)!.value).toEqual(3);
+    expect(model.getters.getCell(0, 2)!.value).toEqual(2);
+  });
+
+  test("async formulas in base data", async () => {
+    const model = new Model({
+      sheets: [
+        {
+          colNumber: 10,
+          rowNumber: 10,
+          cells: { B2: { content: "=WAIT(3)" } },
+        },
+      ],
+    });
+
+    expect(model.getters.getCell(1, 1)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(1, 1)!.value).toEqual(LOADING);
+    let updates = 0;
+    model.on("update", null, () => updates++);
+    expect(updates).toBe(0);
+    await waitForRecompute();
+    expect(updates).toBe(1);
+    expect(model["workbook"].activeSheet.cells["B2"].value).toEqual(3);
+  });
+
+  test("async formula, on update", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=3" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=?WAIT(33)" });
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(1);
+
+    await waitForRecompute();
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(33);
+  });
+
+  test("async formula (async function inside async function)", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=WAIT(WAIT(3))" });
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(1);
+    // Inner wait is resolved
+    await waitForRecompute();
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(1);
+
+    // outer wait is resolved
+    await waitForRecompute();
+
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(3);
+  });
+
+  test("async formula, and value depending on it", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=WAIT(3)" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=1 + A1" });
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(false);
+    expect(model.getters.getCell(0, 0)!.value).toEqual(LOADING);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(1);
+
+    await waitForRecompute();
+    expect(model["workbook"].activeSheet.cells["A1"].value).toEqual(3);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(4);
+    expect(patch.calls.length).toBe(0);
+  });
+
+  test("async formula, and multiple values depending on it", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=WAIT(3)" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=WAIT(1)" });
+    model.dispatch("SET_VALUE", { xc: "A3", text: "=A1 + A2" });
+
+    expect(model.getters.getCell(0, 2)!.formula!.compiledFormula.async).toBe(false);
+    expect(model.getters.getCell(0, 0)!.value).toEqual(LOADING);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(model.getters.getCell(0, 2)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(2);
+    await waitForRecompute();
+    expect(model["workbook"].activeSheet.cells["A1"].value).toEqual(3);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(1);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(4);
+    expect(patch.calls.length).toBe(0);
+  });
+
+  test("async formula, another configuration", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=1" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=WAIT(A1 + 3)" });
+    model.dispatch("SET_VALUE", { xc: "A3", text: "=2 + Wait(3 + Wait(A2))" });
+
+    expect(model["workbook"].activeSheet.cells["A1"].value).toEqual(1);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(LOADING);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(LOADING);
+
+    await waitForRecompute();
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(4);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(LOADING);
+    // We need two resolveAll, one for Wait(A2) and the second for (Wait(3 + 4))
+    await waitForRecompute();
+    await waitForRecompute();
+
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(4);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(9);
+  });
+
+  test("async formula, multi levels", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=WAIT(1)" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=SUM(A1)" });
+    model.dispatch("SET_VALUE", { xc: "A3", text: "=SUM(A2)" });
+
+    expect(model["workbook"].activeSheet.cells["A1"].value).toEqual(LOADING);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(LOADING);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(LOADING);
+
+    await waitForRecompute();
+
+    expect(model["workbook"].activeSheet.cells["A1"].value).toEqual(1);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(1);
+    expect(model["workbook"].activeSheet.cells["A3"].value).toEqual(1);
+  });
+
+  test("async formula, with another cell in sync error", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=A1" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=WAIT(3)" });
+    let updateNbr = 0;
+    model.on("update", null, () => updateNbr++);
+
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(true);
+    expect(model.getters.getCell(0, 0)!.value).toEqual("#CYCLE");
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    expect(patch.calls.length).toBe(1);
+    updateNbr = 0;
+    await waitForRecompute();
+    // next assertion checks that the interface has properly been
+    // notified that the state did change
+    expect(updateNbr).toBe(1);
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(3);
+  });
+
+  test("async formula and errors, scenario 1", async () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=WAIT(3)" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=A1 + 1/0" });
+
+    expect(model.getters.getCell(0, 1)!.formula!.compiledFormula.async).toBe(false);
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+
+    await waitForRecompute();
+
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual("#ERROR");
+
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=WAIT(4)" });
+
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual(LOADING);
+
+    await waitForRecompute();
+
+    expect(model["workbook"].activeSheet.cells["A2"].value).toEqual("#ERROR");
+  });
+
+  test("sync formula depending on error async cell", async () => {
+    functionRegistry.add("CRASHING", {
+      async: true,
+      description: "This async formula crashes",
+      args: args(``),
+      compute: () => {
+        throw new Error("I crashed");
+      },
+      returns: ["ANY"],
+    });
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=CRASHING()" });
+    model.dispatch("SET_VALUE", { xc: "A2", text: "=SUM(A1)" });
+    await asyncComputations();
+    expect(model.getters.getCell(0, 0)!.value).toEqual("#ERROR");
+    expect(model.getters.getCell(0, 1)!.value).toEqual(LOADING);
+    await asyncComputations();
+    expect(model.getters.getCell(0, 0)!.value).toEqual("#ERROR");
+    expect(model.getters.getCell(0, 1)!.value).toEqual("#ERROR");
+  });
+
+  test("async formulas in errors are re-evaluated", async () => {
+    functionRegistry.add("ONLYPOSITIVE", {
+      async: true,
+      description: "This async formula crashes for negative numbers",
+      args: args(`value (number)`),
+      compute: (value) => {
+        if (value < 0) {
+          throw new Error("I only like positive numbers");
+        }
+        return value;
+      },
+      returns: ["ANY"],
+    });
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A2", text: "-1" });
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=ONLYPOSITIVE(A2)" });
+    await asyncComputations();
+    expect(model.getters.getCell(0, 0)!.value).toEqual("#ERROR");
+    model.dispatch("SET_VALUE", { xc: "A2", text: "1" });
+    await asyncComputations();
+    expect(model.getters.getCell(0, 0)!.value).toEqual(1);
+  });
+
+  test("async formulas rejected with a reason", async () => {
+    functionRegistry.add("REJECT", {
+      async: true,
+      description: "This async formula is rejected",
+      args: args(`value (any, optional)`),
+      compute: (value: string | undefined) => {
+        return new Promise((resolve, reject) => reject(value || undefined));
+      },
+      returns: ["ANY"],
+    });
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: `=REJECT("This is an error")` });
+    model.dispatch("SET_VALUE", { xc: "A2", text: `=REJECT()` });
+    model.dispatch("SET_VALUE", { xc: "A3", text: `=REJECT(4)` });
+    await asyncComputations();
+    expect(model.getters.getCell(0, 0)!.value).toBe("#ERROR");
+    expect(model.getters.getCell(0, 1)!.value).toBe("#ERROR");
+    expect(model.getters.getCell(0, 2)!.value).toBe("#ERROR");
+    expect(model.getters.getCell(0, 0)!.error).toBe("This is an error");
+    expect(model.getters.getCell(0, 1)!.error).toBe("");
+    expect(model.getters.getCell(0, 2)!.error).toBe("4");
+  });
+
+  test("sync formula that depends on multiple async formula should not require as many evaluation as they have async dependencies", async () => {
+    const model = new Model({
+      sheets: [
+        {
+          id: "Sheet1",
+          name: "Sheet1",
+          cells: {
+            A1: { content: "=sum(Sheet2!a1:a2)" },
+            A2: { content: "=Sheet2!a2+Sheet2!a3" },
+          },
+        },
+        {
+          id: "Sheet2",
+          name: "Sheet2",
+          cells: {
+            A1: { content: "=wait(100)" },
+            A2: { content: "=wait(100)" },
+            A3: { content: "=wait(100)" },
+          },
+        },
+      ],
+    });
+    await waitForRecompute();
+    expect(model.getters.getCell(...toCartesian("A1"))!.value).toBe(200);
+    // this one will not be able to compute in one go because there is no relation between all the depending cells
+    expect(model.getters.getCell(...toCartesian("A2"))!.value).toBe("Loading...");
+    await waitForRecompute();
+    expect(model.getters.getCell(...toCartesian("A2"))!.value).toBe(200);
+  });
+
+  describe("Async evaluation with cells that are at the same position on different sheets", () => {
+    test("Sheet at position 1", async () => {
+      const model = new Model({
+        sheets: [
+          {
+            id: "Sheet1",
+            name: "Sheet1",
+            cells: {
+              B2: { content: "=Sheet2!B2" },
+            },
+          },
+          {
+            id: "Sheet2",
+            name: "Sheet2",
+            cells: {
+              B1: { content: "=WAIT(50)" },
+              B2: { content: "=B1" },
+            },
+          },
+        ],
+        activeSheet: "Sheet1",
+      });
+      await waitForRecompute();
+      expect(model.getters.getCell(1, 1, "Sheet1")!.value).toBe(50);
+    });
+    test("Sheet at position 2", async () => {
+      const model = new Model({
+        sheets: [
+          {
+            id: "Sheet1",
+            name: "Sheet1",
+            cells: {
+              A1: { content: "=WAIT(50)" },
+              A2: { content: "=A1" },
+            },
+          },
+          {
+            id: "Sheet2",
+            name: "Sheet2",
+            cells: {
+              A2: { content: "=Sheet1!A2" },
+            },
+          },
+        ],
+        activeSheet: "Sheet2",
+      });
+      await waitForRecompute();
+      expect(model.getters.getCell(0, 1, "Sheet2")!.value).toBe(50);
+    });
+  });
+});

package/tests/plugins/evaluation_dates_test.ts

@@ -0,0 +1,79 @@
+import { Model } from "../../src/model";
+import "../canvas.mock";
+import { evaluateCell, evaluateCellText, evaluateGrid, getCell } from "../helpers";
+
+describe("evaluateCells", () => {
+  test("Various date representations", () => {
+    const grid = {
+      A1: "1/2/2020",
+      A2: "02/26/1920",
+      A3: "04/3/2010",
+      B1: "1-2-2020",
+      B2: "02-26-1920",
+      B3: "04-3-2010",
+      C1: "1 2 2020",
+      C2: "02 26 1920",
+      C3: "04 3 2010",
+      D1: "2020/1/2",
+      D2: "1920/02/26",
+      D3: "2010/04/3",
+      E1: "2020-1-2",
+      E2: "1920-02-26",
+      E3: "2010-04-3",
+      F1: "2020 1 2",
+      F2: "1920 02 26",
+      F3: "2010 04 3",
+    };
+    expect(evaluateGrid(grid)).toEqual({
+      A1: { format: "m/d/yyyy", jsDate: new Date(2020, 0, 2), value: 43832 },
+      A2: { format: "mm/dd/yyyy", jsDate: new Date(1920, 1, 26), value: 7362 },
+      A3: { format: "mm/dd/yyyy", jsDate: new Date(2010, 3, 3), value: 40271 },
+      B1: { format: "m-d-yyyy", jsDate: new Date(2020, 0, 2), value: 43832 },
+      B2: { format: "mm-dd-yyyy", jsDate: new Date(1920, 1, 26), value: 7362 },
+      B3: { format: "mm-dd-yyyy", jsDate: new Date(2010, 3, 3), value: 40271 },
+      C1: { format: "m d yyyy", jsDate: new Date(2020, 0, 2), value: 43832 },
+      C2: { format: "mm dd yyyy", jsDate: new Date(1920, 1, 26), value: 7362 },
+      C3: { format: "mm dd yyyy", jsDate: new Date(2010, 3, 3), value: 40271 },
+      D1: { format: "yyyy/m/d", jsDate: new Date(2020, 0, 2), value: 43832 },
+      D2: { format: "yyyy/mm/dd", jsDate: new Date(1920, 1, 26), value: 7362 },
+      D3: { format: "yyyy/mm/dd", jsDate: new Date(2010, 3, 3), value: 40271 },
+      E1: { format: "yyyy-m-d", jsDate: new Date(2020, 0, 2), value: 43832 },
+      E2: { format: "yyyy-mm-dd", jsDate: new Date(1920, 1, 26), value: 7362 },
+      E3: { format: "yyyy-mm-dd", jsDate: new Date(2010, 3, 3), value: 40271 },
+      F1: { format: "yyyy m d", jsDate: new Date(2020, 0, 2), value: 43832 },
+      F2: { format: "yyyy mm dd", jsDate: new Date(1920, 1, 26), value: 7362 },
+      F3: { format: "yyyy mm dd", jsDate: new Date(2010, 3, 3), value: 40271 },
+    });
+  });
+
+  test("date representation is preserved when displayed", () => {
+    const model = new Model();
+    model.dispatch("SET_VALUE", { xc: "A1", text: "1/1/2020" });
+    expect(model.getters.getCellText(getCell(model, "A1")!)).toEqual("1/1/2020");
+  });
+
+  test("adding a date and a number", () => {
+    const grid = {
+      A1: "1/2/2020",
+      A2: "=A1+1",
+    };
+    expect(evaluateCellText("A2", grid)).toEqual("1/3/2020");
+  });
+
+  test("adding a date in mm/d/yyyy format and a number", () => {
+    const grid = {
+      A1: "01/12/2020",
+      A2: "=A1+1",
+    };
+    expect(evaluateCellText("A2", grid)).toEqual("01/13/2020");
+  });
+
+  test("adding two dates", () => {
+    const grid = {
+      A1: "2/3/2020",
+      A2: "1/2/1940",
+      A3: "=A1+A2",
+    };
+    expect(evaluateCell("A3", grid)).toEqual(58476);
+  });
+});