@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/tests/plugins/grid_manipulation_test.ts

@@ -1,1366 +0,0 @@
-import { DEFAULT_CELL_HEIGHT, DEFAULT_CELL_WIDTH } from "../../src/constants";
-import { Model } from "../../src/model";
-import { getSheet, makeTestFixture } from "../helpers";
-let model: Model;
-
-function undo() {
-  model.dispatch("UNDO");
-}
-
-function redo() {
-  model.dispatch("REDO");
-}
-
-function clearColumns(indexes: number[]) {
-  const target = indexes.map((index) => {
-    return model.getters.getColsZone(index, index);
-  });
-  model.dispatch("DELETE_CONTENT", {
-    target,
-    sheet: model["workbook"].activeSheet.id,
-  });
-}
-
-function clearRows(indexes: number[]) {
-  const target = indexes.map((index) => {
-    return model.getters.getRowsZone(index, index);
-  });
-  model.dispatch("DELETE_CONTENT", {
-    target,
-    sheet: model["workbook"].activeSheet.id,
-  });
-}
-
-function removeColumns(columns: number[]) {
-  model.dispatch("REMOVE_COLUMNS", { sheet: model.getters.getActiveSheet(), columns });
-}
-
-function removeRows(rows: number[]) {
-  model.dispatch("REMOVE_ROWS", { sheet: model.getters.getActiveSheet(), rows });
-}
-
-function addColumns(column: number, position: "before" | "after", quantity: number) {
-  model.dispatch("ADD_COLUMNS", {
-    sheet: model.getters.getActiveSheet(),
-    position,
-    column,
-    quantity,
-  });
-}
-
-function addRows(row: number, position: "before" | "after", quantity: number) {
-  model.dispatch("ADD_ROWS", {
-    sheet: model.getters.getActiveSheet(),
-    position,
-    row,
-    quantity,
-  });
-}
-
-const fullData = {
-  sheets: [
-    {
-      colNumber: 4,
-      rowNumber: 4,
-      cells: {
-        A1: { content: "1", style: 1, border: 1 },
-        A2: { content: "2", style: 1, border: 1 },
-        A3: { content: "3", style: 1, border: 1 },
-        A4: { content: "4", style: 1, border: 1 },
-        B1: { content: "1", style: 1, border: 1 },
-        B2: { content: "2", style: 1 },
-        B3: { content: "3", border: 1 },
-        C1: { content: "1" },
-        C3: { content: "3" },
-      },
-      merges: ["A4:D4", "C1:D2"],
-      cols: { 1: { size: 42 } },
-      rows: { 1: { size: 42 } },
-    },
-  ],
-  styles: { 1: { textColor: "#fe0000" } },
-  borders: { 1: { top: ["thin", "#000"] } },
-};
-
-//------------------------------------------------------------------------------
-// Clear
-//------------------------------------------------------------------------------
-
-describe("Clear columns", () => {
-  test("Can clear multiple column", () => {
-    model = new Model({
-      sheets: [
-        {
-          colNumber: 3,
-          rowNumber: 3,
-          cells: {
-            A1: { content: "A1" },
-            A2: { content: "A2" },
-            A3: { content: "A3" },
-            B1: { content: "B1", style: 1, border: 1 },
-            B2: { content: "B2" },
-            C1: { content: "C1", style: 1 },
-            C2: { content: "C2", border: 1 },
-          },
-        },
-      ],
-      styles: { 1: { textColor: "#fe0000" } },
-      borders: { 1: { right: ["thin", "#000"] } },
-      merges: ["A3:B3"],
-    });
-
-    clearColumns([1, 2]);
-    expect(model["workbook"].activeSheet.cells.B2).toBeUndefined();
-    expect(model["workbook"].activeSheet.cells).toMatchObject({
-      A1: { content: "A1" },
-      A2: { content: "A2" },
-      A3: { content: "A3" },
-      B1: { content: "", style: 1, border: 1 },
-      C1: { content: "", style: 1 },
-      C2: { content: "", border: 1 },
-    });
-  });
-});
-
-describe("Clear rows", () => {
-  test("Can clear multiple rows", () => {
-    model = new Model({
-      sheets: [
-        {
-          colNumber: 3,
-          rowNumber: 3,
-          cells: {
-            A1: { content: "A1" },
-            A2: { content: "A2", style: 1, border: 1 },
-            A3: { content: "A3", border: 1 },
-            B1: { content: "B1" },
-            B2: { content: "B2" },
-            C1: { content: "C1" },
-            C2: { content: "C2", style: 1 },
-          },
-        },
-      ],
-      styles: { 1: { textColor: "#fe0000" } },
-      borders: { 1: { right: ["thin", "#000"] } },
-      merges: ["C1:C2"],
-    });
-
-    clearRows([1, 2]);
-    expect(model["workbook"].activeSheet.cells.B2).toBeUndefined();
-    expect(model["workbook"].activeSheet.cells).toMatchObject({
-      A1: { content: "A1" },
-      A2: { content: "", style: 1, border: 1 },
-      A3: { content: "", border: 1 },
-      B1: { content: "B1" },
-      C1: { content: "C1" },
-      C2: { content: "", style: 1 },
-    });
-  });
-});
-
-//------------------------------------------------------------------------------
-// Columns
-//------------------------------------------------------------------------------
-
-describe("Columns", () => {
-  beforeAll(() => {
-    makeTestFixture();
-  });
-  describe("Correctly update size, name, order and number", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 1,
-            cols: {
-              1: { size: 10 },
-              2: { size: 20 },
-            },
-          },
-        ],
-      });
-    });
-    test("On deletion", () => {
-      removeColumns([0, 2]);
-      expect(model["workbook"].activeSheet.cols).toEqual([
-        { start: 0, end: 10, size: 10, name: "A" },
-        { start: 10, end: 10 + DEFAULT_CELL_WIDTH, size: DEFAULT_CELL_WIDTH, name: "B" },
-      ]);
-      expect(model["workbook"].activeSheet.colNumber).toBe(2);
-    });
-    test("On delete cols in inactive sheet", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "B2 in sheet1" },
-            },
-          },
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "B2 in sheet2" },
-            },
-          },
-        ],
-      });
-      const [sheet1, sheet2] = model.getters.getSheets();
-      expect(sheet2).not.toBe(model.getters.getActiveSheet());
-      model.dispatch("REMOVE_COLUMNS", {
-        columns: [0],
-        sheet: sheet2.id,
-      });
-      expect(sheet1.cells.B2.content).toBe("B2 in sheet1");
-      expect(sheet2.cells.A2.content).toBe("B2 in sheet2");
-    });
-    test("On addition before", () => {
-      addColumns(1, "before", 2);
-      const size = DEFAULT_CELL_WIDTH;
-      expect(model["workbook"].activeSheet.cols).toEqual([
-        { start: 0, end: size, size, name: "A" },
-        { start: size, end: size + 10, size: 10, name: "B" },
-        { start: size + 10, end: size + 20, size: 10, name: "C" },
-        { start: size + 20, end: size + 30, size: 10, name: "D" },
-        { start: size + 30, end: size + 50, size: 20, name: "E" },
-        { start: size + 50, end: 2 * size + 50, size, name: "F" },
-      ]);
-      expect(model["workbook"].activeSheet.colNumber).toBe(6);
-    });
-    test("On addition after", () => {
-      addColumns(2, "after", 2);
-      const size = DEFAULT_CELL_WIDTH;
-      expect(model["workbook"].activeSheet.cols).toEqual([
-        { start: 0, end: size, size, name: "A" },
-        { start: size, end: size + 10, size: 10, name: "B" },
-        { start: size + 10, end: size + 30, size: 20, name: "C" },
-        { start: size + 30, end: size + 50, size: 20, name: "D" },
-        { start: size + 50, end: size + 70, size: 20, name: "E" },
-        { start: size + 70, end: 2 * size + 70, size, name: "F" },
-      ]);
-      expect(model["workbook"].activeSheet.colNumber).toBe(6);
-    });
-  });
-
-  describe("Correctly update merges", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 5,
-            rowNumber: 4,
-            merges: ["A1:E1", "B2:E2", "C3:E3", "B4:D4"],
-          },
-        ],
-      });
-    });
-
-    test("On deletion", () => {
-      removeColumns([1, 3]);
-      expect(model["workbook"].activeSheet.merges).toEqual({
-        5: { id: 5, topLeft: "A1", top: 0, bottom: 0, left: 0, right: 2 },
-        6: { id: 6, topLeft: "B2", top: 1, bottom: 1, left: 1, right: 2 },
-        7: { id: 7, topLeft: "B3", top: 2, bottom: 2, left: 1, right: 2 },
-      });
-      expect(model["workbook"].activeSheet.mergeCellMap).toEqual({
-        A1: 5,
-        B1: 5,
-        C1: 5,
-        B2: 6,
-        C2: 6,
-        B3: 7,
-        C3: 7,
-      });
-    });
-
-    test("On addition", () => {
-      addColumns(1, "before", 1);
-      addColumns(0, "after", 1);
-      expect(model["workbook"].activeSheet.merges).toEqual({
-        9: { id: 9, topLeft: "A1", top: 0, bottom: 0, left: 0, right: 6 },
-        10: { id: 10, topLeft: "D2", top: 1, bottom: 1, left: 3, right: 6 },
-        11: { id: 11, topLeft: "E3", top: 2, bottom: 2, left: 4, right: 6 },
-        12: { id: 12, topLeft: "D4", top: 3, bottom: 3, left: 3, right: 5 },
-      });
-      expect(model["workbook"].activeSheet.mergeCellMap).toEqual({
-        A1: 9,
-        B1: 9,
-        C1: 9,
-        D1: 9,
-        E1: 9,
-        F1: 9,
-        G1: 9,
-        D2: 10,
-        E2: 10,
-        F2: 10,
-        G2: 10,
-        E3: 11,
-        F3: 11,
-        G3: 11,
-        D4: 12,
-        E4: 12,
-        F4: 12,
-      });
-    });
-  });
-
-  describe("Correctly update border and style", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 4,
-            cells: {
-              A1: { style: 1 },
-              A2: { border: 1 },
-              A3: { style: 1, border: 1 },
-              B1: { style: 1 },
-              B2: { border: 1 },
-              B3: { style: 1, border: 1, format: "0.00%" },
-              B4: { style: 1, border: 1 },
-              D1: { style: 1 },
-              D2: { border: 1 },
-              D3: { style: 1, border: 1 },
-            },
-            merges: ["B4:C4"],
-          },
-        ],
-        styles: { 1: { textColor: "#fe0000" } },
-        borders: { 1: { top: ["thin", "#000"] } },
-      });
-    });
-    test("On deletion", () => {
-      removeColumns([1]);
-      expect(model["workbook"].activeSheet.cells.B1).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells.B2).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells.B3).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells).toMatchObject({
-        A1: { style: 1 },
-        A2: { border: 1 },
-        A3: { style: 1, border: 1 },
-        B4: { style: 1, border: 1 },
-        C1: { style: 1 },
-        C2: { border: 1 },
-        C3: { style: 1, border: 1 },
-      });
-    });
-    test("On addition", () => {
-      addColumns(1, "before", 1);
-      addColumns(2, "after", 2);
-      expect(model["workbook"].activeSheet.cells).toMatchObject({
-        A1: { style: 1 },
-        A2: { border: 1 },
-        A3: { style: 1, border: 1 },
-        B1: { style: 1 },
-        B2: { border: 1 },
-        B3: { style: 1, border: 1, format: "0.00%" },
-        B4: { style: 1 },
-        C1: { style: 1 },
-        C2: { border: 1 },
-        C3: { style: 1, border: 1, format: "0.00%" },
-        C4: { style: 1, border: 1 },
-        E1: { style: 1 },
-      });
-      expect(Object.values(model["workbook"].activeSheet.merges)[0]).toMatchObject({
-        left: 2,
-        right: 5,
-        topLeft: "C4",
-      });
-    });
-  });
-
-  describe("Correctly update references", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 7,
-            rowNumber: 7,
-            cells: {
-              A1: { content: "=B1" },
-              A2: { content: "=Sheet1!B1" },
-              A3: { content: "=Sheet2!B1" },
-              D1: { content: "=A1" },
-              D2: { content: "=B1" },
-              D3: { content: "=$E1" },
-              D4: { content: "=D3" },
-              A5: { content: "=SUM(A1:D1)" },
-              A6: { content: "=SUM(C1:D1)" },
-              A7: { content: "=SUM(B1:B2)" },
-            },
-          },
-          {
-            colNumber: 1,
-            rowNumber: 3,
-            cells: {
-              A1: { content: "=B1" },
-              A2: { content: "=Sheet1!B1" },
-              A3: { content: "=Sheet2!B1" },
-            },
-          },
-        ],
-      });
-    });
-    test("On deletion", () => {
-      removeColumns([1, 2]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=#REF" },
-        A2: { content: "=#REF" },
-        A3: { content: "=Sheet2!B1" },
-        B1: { content: "=A1" },
-        B2: { content: "=#REF" },
-        B3: { content: "=$C1" },
-        B4: { content: "=B3" },
-      });
-      expect(getSheet(model, 1).cells).toMatchObject({
-        A1: { content: "=B1" },
-        A2: { content: "=#REF" },
-        A3: { content: "=Sheet2!B1" },
-      });
-    });
-    test("delete col on inactive sheet", () => {
-      const model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 7,
-            cells: {
-              B2: { content: "=Sheet1!B3" },
-              C1: { content: "=Sheet2!B3" },
-            },
-          },
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              A2: { content: "=B2" },
-              B2: { content: "=Sheet1!B2" },
-              C2: { content: "=Sheet2!B2" },
-            },
-          },
-        ],
-      });
-      const [sheet1, sheet2] = model.getters.getSheets();
-      expect(sheet2.id).not.toBe(model.getters.getActiveSheet());
-      model.dispatch("REMOVE_COLUMNS", {
-        columns: [0],
-        sheet: sheet2.id,
-      });
-      expect(sheet1.cells).toMatchObject({
-        B2: { content: "=Sheet1!B3" },
-        C1: { content: "=Sheet2!A3" },
-      });
-      expect(sheet2.cells).toMatchObject({
-        A2: { content: "=Sheet1!B2" },
-        B2: { content: "=Sheet2!A2" },
-      });
-    });
-    test("On first col deletion", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "=SUM(A1:C1)" },
-            },
-          },
-        ],
-      });
-      removeColumns([0]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A2: { content: "=SUM(A1:B1)" },
-      });
-    });
-    test("On multiple col deletion including the first one", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              C2: { content: "=SUM(A1:D1)" },
-            },
-          },
-        ],
-      });
-      removeColumns([0, 1]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A2: { content: "=SUM(A1:B1)" },
-      });
-    });
-    test("On last col deletion", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              A2: { content: "=SUM(A1:C1)" },
-            },
-          },
-        ],
-      });
-      removeColumns([2]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A2: { content: "=SUM(A1:B1)" },
-      });
-    });
-    test("delete all columns of a range", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 9,
-            rowNumber: 5,
-            cells: {
-              A1: { content: "=SUM(B2:E5)" },
-              A2: { content: "=SUM(F1:F2)" }, // single column range
-            },
-          },
-        ],
-      });
-
-      removeColumns([5]);
-      expect(getSheet(model, 0).cells.A2.content).toBe("=SUM(#REF)");
-      removeColumns([1, 2, 3, 4]);
-      expect(getSheet(model, 0).cells.A1.content).toBe("=SUM(#REF)");
-    });
-    test("update cross sheet range on column deletion", () => {
-      model = new Model({
-        sheets: [
-          { name: "Sheet1", colNumber: 5, rowNumber: 5 },
-          {
-            name: "Sheet2",
-            colNumber: 3,
-            rowNumber: 9,
-            cells: {
-              A1: { content: "=SUM(Sheet1!B1:D3)" },
-            },
-          },
-        ],
-      });
-      removeColumns([0]);
-      expect(model.getters.getCell(0, 0, "Sheet2")!.content).toBe("=SUM(Sheet1!A1:C3)");
-    });
-    test("update cross sheet range on column deletion in inactive sheet", () => {
-      model = new Model({
-        sheets: [
-          { name: "Sheet0", colNumber: 1, rowNumber: 1 }, // <-- less column than Sheet1
-          { name: "Sheet1", colNumber: 5, rowNumber: 5 },
-          {
-            name: "Sheet2",
-            colNumber: 5,
-            rowNumber: 9,
-            cells: {
-              A1: { content: "=SUM(Sheet1!B1:D3)" },
-            },
-          },
-        ],
-      });
-      const sheet1Id = model.getters.getSheetIdByName("Sheet1");
-      model.dispatch("REMOVE_COLUMNS", { sheet: sheet1Id!, columns: [0] });
-      expect(model.getters.getCell(0, 0, "Sheet2")!.content).toBe("=SUM(Sheet1!A1:C3)");
-    });
-    test("On multiple col deletion including the last one", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              A2: { content: "=SUM(A1:D1)" },
-            },
-          },
-        ],
-      });
-      removeColumns([2, 3]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A2: { content: "=SUM(A1:B1)" },
-      });
-    });
-    test("On addition", () => {
-      addColumns(1, "before", 1);
-      addColumns(0, "after", 1);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=D1" },
-        A2: { content: "=Sheet1!D1" },
-        A3: { content: "=Sheet2!B1" },
-        F1: { content: "=A1" },
-        F2: { content: "=D1" },
-        F3: { content: "=$G1" },
-        F4: { content: "=F3" },
-        A5: { content: "=SUM(A1:F1)" },
-        A6: { content: "=SUM(E1:F1)" },
-        A7: { content: "=SUM(D1:D2)" },
-      });
-      expect(getSheet(model, 1).cells).toMatchObject({
-        A1: { content: "=B1" },
-        A2: { content: "=Sheet1!D1" },
-        A3: { content: "=Sheet2!B1" },
-      });
-    });
-  });
-
-  describe("Correctly handle undo/redo", () => {
-    test("On deletion", () => {
-      model = new Model(fullData);
-      const beforeRemove = model.exportData();
-      removeColumns([0, 2]);
-      const afterRemove = model.exportData();
-      undo();
-      expect(model.exportData()).toEqual(beforeRemove);
-      redo();
-      expect(model.exportData()).toEqual(afterRemove);
-    });
-    test("On addition", () => {
-      model = new Model(fullData);
-      const beforeAdd = model.exportData();
-      addColumns(1, "before", 4);
-      const afterAdd1 = model.exportData();
-      addColumns(4, "after", 4);
-      const afterAdd2 = model.exportData();
-      undo();
-      expect(model.exportData()).toEqual(afterAdd1);
-      redo();
-      expect(model.exportData()).toEqual(afterAdd2);
-      undo();
-      undo();
-      expect(model.exportData()).toEqual(beforeAdd);
-    });
-  });
-
-  describe("Correctly update selection", () => {
-    test("On add left 1", () => {
-      model = new Model(fullData);
-      const zone = { left: 1, right: 3, top: 0, bottom: 2 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-      addColumns(1, "before", 1);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 2, right: 4, top: 0 });
-    });
-    test("On add left 3", () => {
-      model = new Model(fullData);
-      const zone = { left: 1, right: 3, top: 0, bottom: 2 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-      addColumns(1, "before", 3);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 4, right: 6, top: 0 });
-    });
-    test("On add right 1", () => {
-      model = new Model(fullData);
-      const zone = { left: 1, right: 3, top: 0, bottom: 2 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-      addColumns(1, "after", 1);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-    });
-    test("On add right 3", () => {
-      model = new Model(fullData);
-      const zone = { left: 1, right: 3, top: 0, bottom: 2 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-      addColumns(1, "after", 1);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-    });
-  });
-});
-
-//------------------------------------------------------------------------------
-// Rows
-//------------------------------------------------------------------------------
-
-describe("Rows", () => {
-  beforeAll(() => {
-    makeTestFixture();
-  });
-  describe("Correctly update size, name, order and number", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 1,
-            rowNumber: 4,
-            rows: {
-              1: { size: 10 },
-              2: { size: 20 },
-            },
-          },
-        ],
-      });
-    });
-    test("On deletion", () => {
-      removeRows([0, 2]);
-      const size = DEFAULT_CELL_HEIGHT;
-      expect(model["workbook"].activeSheet.rows).toEqual([
-        { start: 0, end: 10, size: 10, name: "1", cells: {} },
-        { start: 10, end: size + 10, size, name: "2", cells: {} },
-      ]);
-      expect(model["workbook"].activeSheet.rowNumber).toBe(2);
-    });
-    test("On delete row in inactive sheet", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "B2 in sheet1" },
-            },
-          },
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "B2 in sheet2" },
-            },
-          },
-        ],
-      });
-      const [sheet1, sheet2] = model.getters.getSheets();
-      expect(sheet2).not.toBe(model.getters.getActiveSheet());
-      model.dispatch("REMOVE_ROWS", {
-        rows: [0],
-        sheet: sheet2.id,
-      });
-      expect(sheet1.cells.B2.content).toBe("B2 in sheet1");
-      expect(sheet2.cells.B1.content).toBe("B2 in sheet2");
-    });
-    test("On deletion batch", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 1,
-            rowNumber: 4,
-            cells: {
-              A1: { content: "A1" },
-              A2: { content: "A2" },
-              A3: { content: "A3" },
-              A4: { content: "A4" },
-            },
-          },
-        ],
-      });
-      removeRows([0, 2, 3]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "A2" },
-      });
-    });
-    test("delete all rows of a range", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 5,
-            rowNumber: 9,
-            cells: {
-              A1: { content: "=SUM(A2:A5)" },
-              B1: { content: "=SUM(B6:C6)" }, // single line range
-            },
-          },
-        ],
-      });
-      removeRows([5]);
-      expect(getSheet(model, 0).cells.B1.content).toBe("=SUM(#REF)");
-      removeRows([1, 2, 3, 4]);
-      expect(getSheet(model, 0).cells.A1.content).toBe("=SUM(#REF)");
-    });
-    test("update cross sheet range on row deletion", () => {
-      model = new Model({
-        sheets: [
-          { name: "Sheet1", colNumber: 5, rowNumber: 5 },
-          {
-            name: "Sheet2",
-            colNumber: 3,
-            rowNumber: 9,
-            cells: {
-              A1: { content: "=SUM(Sheet1!A2:A3)" },
-            },
-          },
-        ],
-      });
-      removeRows([0]);
-      expect(model.getters.getCell(0, 0, "Sheet2")!.content).toBe("=SUM(Sheet1!A1:A2)");
-    });
-    test("update cross sheet range on row deletion in inactive sheet", () => {
-      model = new Model({
-        sheets: [
-          { name: "Sheet0", colNumber: 1, rowNumber: 1 }, // <-- less rows than Sheet1
-          { name: "Sheet1", colNumber: 5, rowNumber: 5 },
-          {
-            name: "Sheet2",
-            colNumber: 5,
-            rowNumber: 9,
-            cells: {
-              A1: { content: "=SUM(Sheet1!A2:A3)" },
-            },
-          },
-        ],
-      });
-      const sheet1Id = model.getters.getSheetIdByName("Sheet1");
-      model.dispatch("REMOVE_ROWS", { sheet: sheet1Id!, rows: [0] });
-      expect(model.getters.getCell(0, 0, "Sheet2")!.content).toBe("=SUM(Sheet1!A1:A2)");
-    });
-    test("On addition before", () => {
-      addRows(1, "before", 2);
-      const size = DEFAULT_CELL_HEIGHT;
-      expect(model["workbook"].activeSheet.rows).toEqual([
-        { start: 0, end: size, size, name: "1", cells: {} },
-        { start: size, end: size + 10, size: 10, name: "2", cells: {} },
-        { start: size + 10, end: size + 20, size: 10, name: "3", cells: {} },
-        { start: size + 20, end: size + 30, size: 10, name: "4", cells: {} },
-        { start: size + 30, end: size + 50, size: 20, name: "5", cells: {} },
-        { start: size + 50, end: 2 * size + 50, size, name: "6", cells: {} },
-      ]);
-      const dimensions = model.getters.getGridSize();
-      expect(dimensions).toEqual([192, 124]);
-      expect(model["workbook"].activeSheet.rowNumber).toBe(6);
-    });
-    test("On addition after", () => {
-      addRows(2, "after", 2);
-      const size = DEFAULT_CELL_HEIGHT;
-      expect(model["workbook"].activeSheet.rows).toEqual([
-        { start: 0, end: size, size, name: "1", cells: {} },
-        { start: size, end: size + 10, size: 10, name: "2", cells: {} },
-        { start: size + 10, end: size + 30, size: 20, name: "3", cells: {} },
-        { start: size + 30, end: size + 50, size: 20, name: "4", cells: {} },
-        { start: size + 50, end: size + 70, size: 20, name: "5", cells: {} },
-        { start: size + 70, end: 2 * size + 70, size, name: "6", cells: {} },
-      ]);
-      const dimensions = model.getters.getGridSize();
-      expect(dimensions).toEqual([192, 144]);
-      expect(model["workbook"].activeSheet.rowNumber).toBe(6);
-    });
-
-    test("activate Sheet: same size", () => {
-      addRows(2, "after", 1);
-      let dimensions = model.getters.getGridSize();
-      expect(dimensions).toEqual([192, 124]);
-      const to = model.getters.getActiveSheet();
-      model.dispatch("CREATE_SHEET", { activate: true, id: "42" });
-      const from = model.getters.getActiveSheet();
-      model.dispatch("ACTIVATE_SHEET", { from, to });
-      dimensions = model.getters.getGridSize();
-      expect(dimensions).toEqual([192, 124]);
-    });
-  });
-
-  describe("Correctly update merges", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 5,
-            merges: ["A1:A5", "B2:B5", "C3:C5", "D2:D4"],
-          },
-        ],
-      });
-    });
-    test("On deletion", () => {
-      removeRows([1, 3]);
-      expect(model["workbook"].activeSheet.merges).toEqual({
-        5: { id: 5, topLeft: "A1", top: 0, bottom: 2, left: 0, right: 0 },
-        6: { id: 6, topLeft: "B2", top: 1, bottom: 2, left: 1, right: 1 },
-        7: { id: 7, topLeft: "C2", top: 1, bottom: 2, left: 2, right: 2 },
-      });
-      expect(model["workbook"].activeSheet.mergeCellMap).toEqual({
-        A1: 5,
-        A2: 5,
-        A3: 5,
-        B2: 6,
-        B3: 6,
-        C2: 7,
-        C3: 7,
-      });
-    });
-    test("On addition", () => {
-      addRows(1, "before", 1);
-      addRows(0, "after", 1);
-      expect(model["workbook"].activeSheet.merges).toEqual({
-        9: { id: 9, topLeft: "A1", top: 0, bottom: 6, left: 0, right: 0 },
-        10: { id: 10, topLeft: "B4", top: 3, bottom: 6, left: 1, right: 1 },
-        11: { id: 11, topLeft: "C5", top: 4, bottom: 6, left: 2, right: 2 },
-        12: { id: 12, topLeft: "D4", top: 3, bottom: 5, left: 3, right: 3 },
-      });
-      expect(model["workbook"].activeSheet.mergeCellMap).toEqual({
-        A1: 9,
-        A2: 9,
-        A3: 9,
-        A4: 9,
-        A5: 9,
-        A6: 9,
-        A7: 9,
-        B4: 10,
-        B5: 10,
-        B6: 10,
-        B7: 10,
-        C5: 11,
-        C6: 11,
-        C7: 11,
-        D4: 12,
-        D5: 12,
-        D6: 12,
-      });
-    });
-  });
-
-  describe("Correctly update border and style", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 4,
-            cells: {
-              A1: { style: 1 },
-              A2: { style: 1 },
-              A4: { style: 1 },
-              B1: { border: 1 },
-              B2: { border: 1 },
-              B4: { border: 1 },
-              C1: { style: 1, border: 1 },
-              C2: { style: 1, border: 1, format: "0.00%" },
-              C4: { style: 1, border: 1 },
-              D2: { style: 1, border: 1 },
-            },
-            merges: ["D2:D3"],
-          },
-        ],
-        styles: { 1: { textColor: "#fe0000" } },
-        borders: { 1: { top: ["thin", "#000"] } },
-      });
-    });
-    test("On deletion", () => {
-      removeRows([1]);
-      expect(model["workbook"].activeSheet.cells.A2).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells.B2).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells.C2).toBeUndefined();
-      expect(model["workbook"].activeSheet.cells).toMatchObject({
-        A1: { style: 1 },
-        A3: { style: 1 },
-        B1: { border: 1 },
-        B3: { border: 1 },
-        C1: { style: 1, border: 1 },
-        C3: { style: 1, border: 1 },
-        D2: { style: 1, border: 1 },
-      });
-    });
-
-    test("On addition", () => {
-      addRows(1, "before", 1);
-      addRows(2, "after", 2);
-      expect(model["workbook"].activeSheet.cells).toMatchObject({
-        A1: { style: 1 },
-        B1: { border: 1 },
-        C1: { style: 1, border: 1 },
-        A2: { style: 1 },
-        B2: { border: 1 },
-        C2: { style: 1, border: 1, format: "0.00%" },
-        D2: { style: 1 },
-        A3: { style: 1 },
-        B3: { border: 1 },
-        C3: { style: 1, border: 1, format: "0.00%" },
-        D3: { style: 1, border: 1 },
-        A5: { style: 1 },
-      });
-      expect(Object.values(model["workbook"].activeSheet.merges)[0]).toMatchObject({
-        top: 2,
-        bottom: 5,
-        topLeft: "D3",
-      });
-    });
-  });
-
-  describe("Correctly update references", () => {
-    beforeEach(() => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 7,
-            rowNumber: 7,
-            cells: {
-              A1: { content: "=A2" },
-              A4: { content: "=A1" },
-              B1: { content: "=Sheet1!A2" },
-              B4: { content: "=B1" },
-              C1: { content: "=Sheet2!A2" },
-              C4: { content: "=A$5" },
-              D4: { content: "=C4" },
-              E1: { content: "=SUM(A1:A4)" },
-              F1: { content: "=SUM(A3:A4)" },
-              G1: { content: "=SUM(B2:C2)" },
-            },
-          },
-          {
-            colNumber: 3,
-            rowNumber: 1,
-            cells: {
-              A1: { content: "=A2" },
-              B1: { content: "=Sheet1!A2" },
-              C1: { content: "=Sheet2!A2" },
-            },
-          },
-        ],
-      });
-    });
-
-    test("On deletion", () => {
-      removeRows([1, 2]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=#REF" },
-        A2: { content: "=A1" },
-        B1: { content: "=#REF" },
-        B2: { content: "=B1" },
-        C1: { content: "=Sheet2!A2" },
-        C2: { content: "=A$3" },
-        D2: { content: "=C2" },
-      });
-      expect(getSheet(model, 1).cells).toMatchObject({
-        A1: { content: "=A2" },
-        B1: { content: "=#REF" },
-        C1: { content: "=Sheet2!A2" },
-      });
-    });
-    test("delete row on inactive sheet", () => {
-      const model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 7,
-            cells: {
-              B2: { content: "=Sheet1!A2" },
-              C1: { content: "=Sheet2!A2" },
-            },
-          },
-          {
-            colNumber: 3,
-            rowNumber: 2,
-            cells: {
-              A2: { content: "=B2" },
-              B2: { content: "=Sheet1!A2" },
-              C2: { content: "=Sheet2!A2" },
-            },
-          },
-        ],
-      });
-      const [sheet1, sheet2] = model.getters.getSheets();
-      expect(sheet2.id).not.toBe(model.getters.getActiveSheet()),
-        model.dispatch("REMOVE_ROWS", {
-          rows: [0],
-          sheet: sheet2.id,
-        });
-      expect(sheet1.cells).toMatchObject({
-        B2: { content: "=Sheet1!A2" },
-        C1: { content: "=Sheet2!A1" },
-      });
-      expect(sheet2.cells).toMatchObject({
-        A1: { content: "=B1" },
-        B1: { content: "=Sheet1!A2" },
-        C1: { content: "=Sheet2!A1" },
-      });
-    });
-    test("On first row deletion", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B2: { content: "=SUM(A1:A3)" },
-            },
-          },
-        ],
-      });
-      removeRows([0]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B1: { content: "=SUM(A1:A2)" },
-      });
-    });
-
-    test("with space in the sheet name", () => {
-      model = new Model({
-        sheets: [
-          {
-            id: "sheet1",
-            name: "Sheet 1",
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              C2: { content: "=SUM('Sheet 1'!B2)" },
-              C3: { content: "=SUM('Sheet 1'!B2:B3)" },
-            },
-          },
-        ],
-      });
-      removeRows([0]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        C1: { content: "=SUM('Sheet 1'!B1)" },
-        C2: { content: "=SUM('Sheet 1'!B1:B2)" },
-      });
-      removeColumns([0]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B1: { content: "=SUM('Sheet 1'!A1)" },
-        B2: { content: "=SUM('Sheet 1'!A1:A2)" },
-      });
-      addColumns(0, "before", 1);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        C1: { content: "=SUM('Sheet 1'!B1)" },
-        C2: { content: "=SUM('Sheet 1'!B1:B2)" },
-      });
-      addRows(0, "before", 1);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        C2: { content: "=SUM('Sheet 1'!B2)" },
-        C3: { content: "=SUM('Sheet 1'!B2:B3)" },
-      });
-    });
-    test("On multiple row deletion including the first one", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 6,
-            cells: {
-              B1: { content: "=SUM(A2:A5)" },
-            },
-          },
-        ],
-      });
-      removeRows([1, 2]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B1: { content: "=SUM(A2:A3)" },
-      });
-    });
-    test("strange test in Odoo", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 1,
-            rowNumber: 1000,
-            cells: {
-              A5: { content: "=SUM(A6:A255)" },
-              A256: { content: "=SUM(A257:A506)" },
-            },
-          },
-        ],
-      });
-      const rows: number[] = [];
-      for (let i = 6; i <= 254; i++) {
-        rows.push(i);
-      }
-      for (let i = 257; i <= 605; i++) {
-        rows.push(i);
-      }
-
-      removeRows(rows);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A5: { content: "=SUM(A6)" },
-        A7: { content: "=SUM(A8)" },
-      });
-    });
-    test("On last row deletion", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 3,
-            rowNumber: 3,
-            cells: {
-              B1: { content: "=SUM(A1:A3)" },
-            },
-          },
-        ],
-      });
-      removeRows([2]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B1: { content: "=SUM(A1:A2)" },
-      });
-    });
-    test("On multiple row", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 1,
-            rowNumber: 8,
-            cells: {
-              A1: { content: "=SUM(A2:A5)" },
-            },
-          },
-        ],
-      });
-      removeRows([2, 3]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=SUM(A2:A3)" },
-      });
-    });
-    test("On multiple rows (7)", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 1,
-            rowNumber: 8,
-            cells: {
-              A1: { content: "=SUM(A2:A8)" },
-            },
-          },
-        ],
-      });
-      removeRows([1, 2, 3, 4, 5, 6]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=SUM(A2)" },
-      });
-    });
-    test("On multiple row deletion including the last one", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 4,
-            rowNumber: 4,
-            cells: {
-              B1: { content: "=SUM(A1:A4)" },
-            },
-          },
-        ],
-      });
-      removeRows([2, 3]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B1: { content: "=SUM(A1:A2)" },
-      });
-    });
-    test("On multiple row deletion including the last and beyond", () => {
-      model = new Model({
-        sheets: [
-          {
-            colNumber: 2,
-            rowNumber: 8,
-            cells: {
-              B2: { content: "=SUM(A1:A4)" },
-            },
-          },
-        ],
-      });
-      removeRows([3, 4, 5, 6, 7]);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        B2: { content: "=SUM(A1:A3)" },
-      });
-    });
-    test("On addition", () => {
-      addRows(1, "before", 1);
-      addRows(0, "after", 1);
-      expect(getSheet(model, 0).cells).toMatchObject({
-        A1: { content: "=A4" },
-        A6: { content: "=A1" },
-        B1: { content: "=Sheet1!A4" },
-        B6: { content: "=B1" },
-        C1: { content: "=Sheet2!A2" },
-        C6: { content: "=A$7" },
-        D6: { content: "=C6" },
-        E1: { content: "=SUM(A1:A6)" },
-        F1: { content: "=SUM(A5:A6)" },
-        G1: { content: "=SUM(B4:C4)" },
-      });
-      expect(getSheet(model, 1).cells).toMatchObject({
-        A1: { content: "=A2" },
-        B1: { content: "=Sheet1!A4" },
-        C1: { content: "=Sheet2!A2" },
-      });
-    });
-  });
-
-  describe("Correctly handle undo/redo", () => {
-    test("On deletion", () => {
-      model = new Model(fullData);
-      const beforeRemove = model.exportData();
-      removeRows([0, 2]);
-      const afterRemove = model.exportData();
-      undo();
-      expect(model.exportData()).toEqual(beforeRemove);
-      redo();
-      expect(model.exportData()).toEqual(afterRemove);
-    });
-
-    test("On addition", () => {
-      model = new Model(fullData);
-      const beforeAdd = model.exportData();
-      addRows(2, "before", 2);
-      const afterAdd1 = model.exportData();
-      addRows(4, "after", 4);
-      const afterAdd2 = model.exportData();
-      undo();
-      expect(model.exportData()).toEqual(afterAdd1);
-      redo();
-      expect(model.exportData()).toEqual(afterAdd2);
-      undo();
-      undo();
-      expect(model.exportData()).toEqual(beforeAdd);
-    });
-  });
-
-  describe("Correctly update selection", () => {
-    test("On add top 1", () => {
-      model = new Model(fullData);
-      const zone = { left: 2, right: 3, top: 0, bottom: 1 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 1, left: 2, right: 3, top: 0 });
-      addRows(0, "before", 1);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 2, right: 3, top: 1 });
-    });
-    test("On add top 3", () => {
-      model = new Model(fullData);
-      const zone = { left: 2, right: 3, top: 0, bottom: 1 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 1, left: 2, right: 3, top: 0 });
-      addRows(0, "before", 3);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 4, left: 2, right: 3, top: 3 });
-    });
-    test("On add bottom 1", () => {
-      model = new Model(fullData);
-      const zone = { left: 2, right: 3, top: 0, bottom: 1 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 1, left: 2, right: 3, top: 0 });
-      addRows(0, "after", 1);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 1, left: 2, right: 3, top: 0 });
-    });
-    test("On add bottom 3", () => {
-      model = new Model(fullData);
-      const zone = { left: 1, right: 3, top: 0, bottom: 2 };
-      model.dispatch("SET_SELECTION", {
-        zones: [zone],
-        anchor: [zone.left, zone.top],
-        strict: true,
-      });
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-      addRows(0, "after", 3);
-      expect(model.getters.getSelectedZone()).toEqual({ bottom: 2, left: 1, right: 3, top: 0 });
-    });
-  });
-});