@odoo/o-spreadsheet 1.0.1

package/tests/helpers/coordinates_test.ts

@@ -0,0 +1,25 @@
+import { numberToLetters, toCartesian, toXC } from "../../src/helpers/index";
+
+describe("numberToLetter", () => {
+  test("basic functionality", () => {
+    expect(numberToLetters(0)).toBe("A");
+    expect(numberToLetters(25)).toBe("Z");
+    expect(numberToLetters(26)).toBe("AA");
+  });
+});
+
+describe("toCartesian", () => {
+  test("basic functionality", () => {
+    expect(toCartesian("A1")).toEqual([0, 0]);
+    expect(toCartesian("B1")).toEqual([1, 0]);
+    expect(toCartesian("C5")).toEqual([2, 4]);
+  });
+});
+
+describe("toXC", () => {
+  test("basic functionality", () => {
+    expect(toXC(0, 0)).toBe("A1");
+    expect(toXC(1, 0)).toBe("B1");
+    expect(toXC(0, 1)).toBe("A2");
+  });
+});

package/tests/helpers/misc_test.ts

@@ -0,0 +1,95 @@
+import { deepCopy } from "../../src/helpers";
+
+describe("deepCopy", () => {
+  test.each([
+    {},
+    [],
+    [{}],
+    [1, 2],
+    ["1", "2"],
+    [undefined],
+    [null],
+    { a: 1 },
+    { a: undefined },
+    { a: null },
+    { a: {} },
+    { a: [] },
+    { a: { b: {} } },
+    { a: { b: [] } },
+    { a: { b: 1 } },
+    { a: { b: "1" } },
+    [{ a: 1 }],
+    [, , "a"],
+    () => 4,
+    1,
+    "1",
+    true,
+    false,
+    undefined,
+    null,
+  ])("deepCopy %s", (obj) => {
+    expect(deepCopy(obj)).toEqual(obj);
+  });
+
+  test.each([new Set(), new Map(), new Set([1]), new Date()])(
+    "unsupported type %s throws an error",
+    (obj) => {
+      expect(() => deepCopy(obj)).toThrow();
+    }
+  );
+
+  test("object is not mutated", () => {
+    const obj = { a: 1 };
+    const copy = deepCopy(obj);
+    copy["a"] = 2;
+    copy["b"] = 2;
+    expect(obj["a"]).toBe(1);
+    expect("b" in obj).toBe(false);
+  });
+
+  test("nested objects is not mutated", () => {
+    const obj = { z: { a: 1 } };
+    const copy = deepCopy(obj);
+    copy["z"]["a"] = 2;
+    copy["z"]["b"] = 2;
+    expect(obj["z"]["a"]).toBe(1);
+    expect("b" in obj["z"]).toBe(false);
+  });
+
+  test("nested nested objects is not mutated", () => {
+    const obj = { y: { z: { a: 1 } } };
+    const copy = deepCopy(obj);
+    copy["y"]["z"]["a"] = 2;
+    copy["y"]["z"]["b"] = 2;
+    expect(obj["y"]["z"]["a"]).toBe(1);
+    expect("b" in obj["y"]["z"]).toBe(false);
+  });
+
+  test("array is not mutated", () => {
+    const arr = [1];
+    const copy = deepCopy(arr);
+    copy.push(2);
+    expect(arr).toEqual([1]);
+  });
+
+  test("nested array is not mutated", () => {
+    const arr = [[1]];
+    const copy = deepCopy(arr);
+    copy[0].push(2);
+    expect(arr[0]).toEqual([1]);
+  });
+
+  test("nested nested array is not mutated", () => {
+    const arr = [[[1]]];
+    const copy = deepCopy(arr);
+    copy[0][0].push(2);
+    expect(arr[0][0]).toEqual([1]);
+  });
+
+  test("preserves sparse arrays", () => {
+    const copy = deepCopy([, , "a"]);
+    expect("0" in copy).toBe(false);
+    expect("1" in copy).toBe(false);
+    expect("2" in copy).toBe(true);
+  });
+});

package/tests/helpers/numbers_test.ts

@@ -0,0 +1,196 @@
+import {
+  formatDecimal,
+  formatNumber,
+  formatPercent,
+  formatStandardNumber,
+  isNumber,
+  parseNumber,
+} from "../../src/helpers/index";
+
+describe("isNumber", () => {
+  test("recognize various number representations", () => {
+    expect(isNumber("1")).toBe(true);
+    expect(isNumber("1.1")).toBe(true);
+    expect(isNumber(".3")).toBe(true);
+    expect(isNumber("1,234")).toBe(true);
+    expect(isNumber("1,234.56")).toBe(true);
+    expect(isNumber("1%")).toBe(true);
+    expect(isNumber("1.5%")).toBe(true);
+    expect(isNumber("1.5 %")).toBe(true);
+    expect(isNumber("-3.3%")).toBe(true);
+    expect(isNumber("1.2e4")).toBe(true);
+    expect(isNumber("1e5")).toBe(true);
+    expect(isNumber("-1e3")).toBe(true);
+  });
+
+  test("some other checks for isNumber", () => {
+    expect(isNumber("")).toBe(false);
+    expect(isNumber("1.1.1")).toBe(false);
+  });
+});
+
+describe("parseNumber", () => {
+  test("parse empty string as 0", () => {
+    expect(parseNumber("")).toBe(0);
+  });
+
+  test("can parse various number representations", () => {
+    expect(parseNumber("1")).toBe(1);
+    expect(parseNumber("1.1")).toBe(1.1);
+    expect(parseNumber(".3")).toBe(0.3);
+    expect(parseNumber("1,234")).toBe(1234);
+    expect(parseNumber("1,234.5")).toBe(1234.5);
+    expect(parseNumber("1%")).toBe(0.01);
+    expect(parseNumber("1 %")).toBe(0.01);
+    expect(parseNumber("1.5%")).toBe(0.015);
+    expect(parseNumber("-3.3%")).toBe(-0.033);
+    expect(parseNumber("1.2e4")).toBe(12000);
+    expect(parseNumber("1e5")).toBe(100000);
+    expect(parseNumber("-1e3")).toBe(-1000);
+  });
+});
+
+describe("formatNumber", () => {
+  test("formatNumber", () => {
+    expect(formatStandardNumber(1)).toBe("1");
+    expect(formatStandardNumber(0)).toBe("0");
+    expect(formatStandardNumber(-1)).toBe("-1");
+    expect(formatStandardNumber(0.1)).toBe("0.1");
+    expect(formatStandardNumber(0.01)).toBe("0.01");
+    expect(formatStandardNumber(0.001)).toBe("0.001");
+    expect(formatStandardNumber(0.0001)).toBe("0.0001");
+    expect(formatStandardNumber(0.00001)).toBe("0.00001");
+    expect(formatStandardNumber(0.000001)).toBe("0.000001");
+    expect(formatStandardNumber(0.0000001)).toBe("0.0000001");
+    expect(formatStandardNumber(0.00000001)).toBe("0.00000001");
+    expect(formatStandardNumber(0.000000001)).toBe("0.000000001");
+    expect(formatStandardNumber(0.0000000001)).toBe("0.0000000001");
+    expect(formatStandardNumber(0.00000000001)).toBe("0");
+    expect(formatStandardNumber(0.000000000001)).toBe("0");
+
+    // @compatibility note: in Google Sheets, the next three tests result in 1234512345
+    expect(formatStandardNumber(1234512345.1)).toBe("1234512345.1");
+    expect(formatStandardNumber(1234512345.12)).toBe("1234512345.12");
+    expect(formatStandardNumber(1234512345.123)).toBe("1234512345.123");
+
+    expect(formatStandardNumber(123.10000000001)).toBe("123.1");
+    expect(formatStandardNumber(123.10000000000000001)).toBe("123.1");
+  });
+
+  test("formatDecimal", () => {
+    expect(formatDecimal(0, 0)).toBe("0");
+    expect(formatDecimal(0, 1)).toBe("0.0");
+    expect(formatDecimal(0, 2)).toBe("0.00");
+    expect(formatDecimal(0, 3)).toBe("0.000");
+
+    expect(formatDecimal(1, 0)).toBe("1");
+    expect(formatDecimal(1, 1)).toBe("1.0");
+    expect(formatDecimal(1, 2)).toBe("1.00");
+    expect(formatDecimal(1, 3)).toBe("1.000");
+
+    expect(formatDecimal(1.1, 0)).toBe("1");
+    expect(formatDecimal(1.1, 1)).toBe("1.1");
+    expect(formatDecimal(1.1, 2)).toBe("1.10");
+    expect(formatDecimal(1.1, 3)).toBe("1.100");
+
+    expect(formatDecimal(5.1, 0)).toBe("5");
+    expect(formatDecimal(5.1, 1)).toBe("5.1");
+    expect(formatDecimal(5.1, 2)).toBe("5.10");
+    expect(formatDecimal(5.1, 3)).toBe("5.100");
+
+    expect(formatDecimal(1.23456789, 0)).toBe("1");
+    expect(formatDecimal(1.23456789, 2)).toBe("1.23");
+    expect(formatDecimal(1.23456789, 5)).toBe("1.23457");
+    expect(formatDecimal(1.23456789, 10)).toBe("1.2345678900");
+
+    expect(formatDecimal(-1, 0)).toBe("-1");
+    expect(formatDecimal(-1, 1)).toBe("-1.0");
+    expect(formatDecimal(-1, 2)).toBe("-1.00");
+    expect(formatDecimal(-1, 3)).toBe("-1.000");
+
+    expect(formatDecimal(-5.1, 0)).toBe("-5");
+    expect(formatDecimal(-5.1, 1)).toBe("-5.1");
+    expect(formatDecimal(-5.1, 2)).toBe("-5.10");
+    expect(formatDecimal(-5.1, 3)).toBe("-5.100");
+
+    expect(formatDecimal(-0.5, 0)).toBe("-1");
+    expect(formatDecimal(-0.5, 1)).toBe("-0.5");
+    expect(formatDecimal(-0.5, 2)).toBe("-0.50");
+    expect(formatDecimal(-0.5, 3)).toBe("-0.500");
+  });
+
+  test("formatDecimal limitied to 20 decimals", () => {
+    expect(formatDecimal(0.42, 20)).toBe("0.42000000000000000000");
+    expect(formatDecimal(0.42, 21)).toBe("0.42000000000000000000");
+  });
+
+  test("formatDecimal, thousand separator", () => {
+    expect(formatDecimal(100, 2, "s")).toBe("100.00");
+    expect(formatDecimal(1000, 2, "s")).toBe("1s000.00");
+    expect(formatDecimal(10000, 2, "s")).toBe("10s000.00");
+    expect(formatDecimal(100000, 2, "s")).toBe("100s000.00");
+    expect(formatDecimal(1000000, 2, "s")).toBe("1s000s000.00");
+  });
+
+  test("formatPercent", () => {
+    expect(formatPercent(0)).toBe("0.00%");
+    expect(formatPercent(0.123)).toBe("12.30%");
+    expect(formatPercent(0.1234)).toBe("12.34%");
+  });
+});
+
+describe("formatNumber function", () => {
+  test("a normal number: #,##0.00", () => {
+    expect(formatNumber(0, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(1, "#,##0.00")).toBe("1.00");
+    expect(formatNumber(1.1, "#,##0.00")).toBe("1.10");
+    expect(formatNumber(5.1, "#,##0.00")).toBe("5.10");
+    expect(formatNumber(-1, "#,##0.00")).toBe("-1.00");
+    expect(formatNumber(10, "#,##0.00")).toBe("10.00");
+    expect(formatNumber(100, "#,##0.00")).toBe("100.00");
+    expect(formatNumber(-100, "#,##0.00")).toBe("-100.00");
+    expect(formatNumber(1000, "#,##0.00")).toBe("1,000.00");
+    expect(formatNumber(10000, "#,##0.00")).toBe("10,000.00");
+    expect(formatNumber(100000, "#,##0.00")).toBe("100,000.00");
+    expect(formatNumber(1000000, "#,##0.00")).toBe("1,000,000.00");
+    expect(formatNumber(-1000000, "#,##0.00")).toBe("-1,000,000.00");
+    expect(formatNumber(0.1, "#,##0.00")).toBe("0.10");
+    expect(formatNumber(0.01, "#,##0.00")).toBe("0.01");
+    expect(formatNumber(0.001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.0001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.00001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.000001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.0000001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.00000001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.000000001, "#,##0.00")).toBe("0.00");
+    expect(formatNumber(0.0000000001, "#,##0.00")).toBe("0.00");
+  });
+
+  test("formatPercent", () => {
+    expect(formatNumber(0, "0.00%")).toBe("0.00%");
+    expect(formatNumber(0.123, "0.00%")).toBe("12.30%");
+    expect(formatNumber(0.1234, "0.00%")).toBe("12.34%");
+    expect(formatNumber(0.12345, "0.00%")).toBe("12.35%");
+  });
+
+  test("formatPercent, with various number of decimals", () => {
+    expect(formatNumber(0.1234, "0%")).toBe("12%");
+    expect(formatNumber(0.1234, "0.0%")).toBe("12.3%");
+    expect(formatNumber(0.1234, "0.00%")).toBe("12.34%");
+    expect(formatNumber(0.1234, "0.000%")).toBe("12.340%");
+  });
+
+  test("can select different formatting for positive/negative", () => {
+    const format = "#,##0.00;0.00%";
+    expect(formatNumber(12345.54, format)).toBe("12,345.54");
+    expect(formatNumber(0, format)).toBe("0.00");
+    expect(formatNumber(-1.2, format)).toBe("120.00%"); // note the lack of - sign
+  });
+
+  test("can select different formatting for positive/negative/zero", () => {
+    const format = "#,##0.0;0.00%;0.000";
+    expect(formatNumber(12345.54, format)).toBe("12,345.5");
+    expect(formatNumber(0, format)).toBe("0.000");
+    expect(formatNumber(-1.2, format)).toBe("120.00%"); // note the lack of - sign
+  });
+});

package/tests/helpers/zones_test.ts

@@ -0,0 +1,97 @@
+import { overlap, recomputeZones, toZone } from "../../src/helpers/index";
+import { Zone } from "../../src/types";
+
+describe("overlap", () => {
+  test("one zone above the other", () => {
+    const z1 = { top: 0, right: 0, bottom: 0, left: 0 };
+    const z2 = { top: 3, right: 0, bottom: 5, left: 0 };
+    expect(overlap(z1, z2)).toBe(false);
+    expect(overlap(z2, z1)).toBe(false);
+  });
+});
+
+describe("recomputeZones", () => {
+  test("add a cell to zone(1)", () => {
+    const toKeep = ["A1:C3", "A4"];
+    const expectedZone = ["A1:A4", "B1:C3"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+
+  test("add a cell to zone(2)", () => {
+    const toKeep = ["A1:C3", "D1"];
+    const expectedZone = ["A1:C3", "D1"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+
+  test("add a row to a zone", () => {
+    const toKeep = ["A1:C3", "A4:C4"];
+    const expectedZone = ["A1:C4"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+
+  test("add a col to a zone", () => {
+    const toKeep = ["A1:C3", "D1:D3"];
+    const expectedZone = ["A1:D3"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+  test("merge zones", () => {
+    const toKeep = ["A1:B3", "B2:C5", "C1:C5"];
+    const expectedZone = ["A1:A3", "B1:C5"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+  test("zones included", () => {
+    const toKeep = ["A1:D6", "A2:C3"];
+    const expectedZone = ["A1:D6"];
+    expect(recomputeZones(toKeep, [])).toEqual(expectedZone);
+  });
+  test("remove a cell (1)", () => {
+    const toKeep = ["A1:D6"];
+    const toRemove = ["A1"];
+    const expectedZone = ["A2:A6", "B1:D6"];
+    expect(recomputeZones(toKeep, toRemove)).toEqual(expectedZone);
+  });
+  test("remove a cell (2)", () => {
+    const toKeep = ["A1:D6"];
+    const toRemove = ["D6"];
+    const expectedZone = ["A1:C6", "D1:D5"];
+    expect(recomputeZones(toKeep, toRemove)).toEqual(expectedZone);
+  });
+  test("remove a cell (3)", () => {
+    const toKeep = ["A1:D6"];
+    const toRemove = ["B3"];
+    const expectedZone = ["A1:A6", "B1:B2", "B4:B6", "C1:D6"];
+    expect(recomputeZones(toKeep, toRemove)).toEqual(expectedZone);
+  });
+  test("remove a zone", () => {
+    const toKeep = ["A1:D6"];
+    const toRemove = ["B1:C6"];
+    const expectedZone = ["A1:A6", "D1:D6"];
+    expect(recomputeZones(toKeep, toRemove)).toEqual(expectedZone);
+  });
+});
+
+describe("toZone", () => {
+  test.each([["A1"], ["$A1"], ["A$1"], ["$A$1"], ["Sheet1!A1"], ["Sheet1!$A$1"]])(
+    "should support different simple cell reference",
+    (range) => {
+      expect(toZone(range)).toStrictEqual({ top: 0, bottom: 0, left: 0, right: 0 } as Zone);
+    }
+  );
+
+  test.each([
+    ["A1:B2"],
+    ["$A1:B2"],
+    ["A$1:B2"],
+    ["A1:$B2"],
+    ["A1:B$2"],
+    ["$A$1:$B$2"],
+    ["Sheet1!A1:B2"],
+    ["Sheet1!$A$1:$B$2"],
+  ])("should support different range reference", (range) => {
+    expect(toZone(range)).toStrictEqual({ top: 0, bottom: 1, left: 0, right: 1 } as Zone);
+  });
+
+  test("should support lowercase cell reference", () => {
+    expect(toZone("c35")).toStrictEqual({ right: 2, top: 34, bottom: 34, left: 2 } as Zone);
+  });
+});