@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/tests/helpers/coordinates_test.ts

@@ -1,25 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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);
-  });
-});