@odoo/o-spreadsheet 14.0.1 → 15.0.0

package/tests/formulas/range_tokenizer_test.ts

@@ -1,187 +0,0 @@
-import { rangeTokenize } from "../../src/formulas";
-
-describe("rangeTokenizer", () => {
-  test("only range", () => {
-    expect(rangeTokenize("=A1:A2")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A1:A2" },
-    ]);
-  });
-  test("operation and no range", () => {
-    expect(rangeTokenize("=A3+A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A3" },
-      { type: "OPERATOR", value: "+" },
-      { type: "SYMBOL", value: "A1" },
-    ]);
-  });
-  test("operation and range", () => {
-    expect(rangeTokenize("=A3+A1:A2")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A3" },
-      { type: "OPERATOR", value: "+" },
-      { type: "SYMBOL", value: "A1:A2" },
-    ]);
-  });
-  test("operation and range with spaces", () => {
-    expect(rangeTokenize("=A3+  A1 : A2   ")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A3" },
-      { type: "OPERATOR", value: "+" },
-      { type: "SYMBOL", value: "A1:A2" },
-    ]);
-  });
-
-  test("range with spaces then operation", () => {
-    expect(rangeTokenize("=  A1 : A2   +a3")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A1:A2" },
-      { type: "OPERATOR", value: "+" },
-      { type: "SYMBOL", value: "a3" },
-    ]);
-  });
-
-  test("= SUM ( C4 : C5 )", () => {
-    expect(rangeTokenize("= SUM ( C4 : C5 )")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SPACE", value: " " },
-      { type: "FUNCTION", value: "SUM" },
-      { type: "SPACE", value: " " },
-      { type: "LEFT_PAREN", value: "(" },
-      { type: "SYMBOL", value: "C4:C5" },
-      { type: "RIGHT_PAREN", value: ")" },
-    ]);
-  });
-});
-
-describe("knows what's a reference and what's not", () => {
-  test("lowercase cell reference", () => {
-    expect(rangeTokenize("=a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "a1" },
-    ]);
-  });
-
-  test("single cell reference", () => {
-    expect(rangeTokenize("=AA1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "AA1" },
-    ]);
-  });
-
-  test("large single cell reference", () => {
-    expect(rangeTokenize("=AA100")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "AA100" },
-    ]);
-  });
-
-  test("fixed cell", () => {
-    expect(rangeTokenize("=$a$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "$a$1" },
-    ]);
-  });
-
-  test("fixed row", () => {
-    expect(rangeTokenize("=a$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "a$1" },
-    ]);
-  });
-
-  test("fixed column", () => {
-    expect(rangeTokenize("=$a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "$a1" },
-    ]);
-  });
-
-  test("sheet, with lowercase cell reference", () => {
-    expect(rangeTokenize("=Sheet3!a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet3!a1" },
-    ]);
-  });
-
-  test("sheet, fixed cell", () => {
-    expect(rangeTokenize("=Sheet3!$a$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet3!$a$1" },
-    ]);
-  });
-
-  test("sheet, fixed row", () => {
-    expect(rangeTokenize("=Sheet3!a$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet3!a$1" },
-    ]);
-  });
-
-  test("sheet, fixed column", () => {
-    expect(rangeTokenize("=Sheet3!$a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet3!$a1" },
-    ]);
-  });
-
-  test("sheet with quotes and spaces", () => {
-    expect(rangeTokenize("='Sheet3'!a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'Sheet3'!a1" },
-    ]);
-    expect(rangeTokenize("='S h i t'!a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'S h i t'!a1" },
-    ]);
-    expect(rangeTokenize("='S ''h i t'!a1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'S ''h i t'!a1" },
-    ]);
-  });
-});
-
-describe("tokenize ranges", () => {
-  test("normal range", () => {
-    expect(rangeTokenize("=A1:B2")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "A1:B2" },
-    ]);
-  });
-
-  test("invalid range should be corrected", () => {
-    expect(rangeTokenize("=B1:A2")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "B1:A2" },
-    ]);
-  });
-
-  test.skip("column", () => {
-    expect(rangeTokenize("=A:A")).toEqual({
-      type: "BIN_OPERATION",
-      value: ":",
-      left: {
-        type: "REFERENCE",
-        value: "A",
-      },
-      right: {
-        type: "REFERENCE",
-        value: "A",
-      },
-    });
-  });
-  test.skip("row", () => {
-    expect(rangeTokenize("=1:1")).toEqual({
-      type: "BIN_OPERATION",
-      value: ":",
-      left: {
-        type: "REFERENCE",
-        value: "1",
-      },
-      right: {
-        type: "REFERENCE",
-        value: "1",
-      },
-    });
-  });
-});

package/tests/formulas/tokenizer_test.ts

@@ -1,164 +0,0 @@
-import { tokenize } from "../../src/formulas";
-
-describe("tokenizer", () => {
-  test("simple token", () => {
-    expect(tokenize("1")).toEqual([{ type: "NUMBER", value: "1" }]);
-  });
-  test("number with decimal token", () => {
-    expect(tokenize("=1.5")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "NUMBER", value: "1.5" },
-    ]);
-  });
-  test("formula token", () => {
-    expect(tokenize("=1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "NUMBER", value: "1" },
-    ]);
-  });
-  test("longer operators >=", () => {
-    expect(tokenize("= >= <= <")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SPACE", value: " " },
-      { type: "OPERATOR", value: ">=" },
-      { type: "SPACE", value: " " },
-      { type: "OPERATOR", value: "<=" },
-      { type: "SPACE", value: " " },
-      { type: "OPERATOR", value: "<" },
-    ]);
-  });
-
-  test("concat operator", () => {
-    expect(tokenize("=&")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "OPERATOR", value: "&" },
-    ]);
-  });
-
-  test("not equal operator", () => {
-    expect(tokenize("=<>")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "OPERATOR", value: "<>" },
-    ]);
-  });
-
-  test("can tokenize various number expressions", () => {
-    expect(tokenize("1%")).toEqual([{ type: "NUMBER", value: "1%" }]);
-    expect(tokenize("1 %")).toEqual([{ type: "NUMBER", value: "1 %" }]);
-    expect(tokenize("1.1")).toEqual([{ type: "NUMBER", value: "1.1" }]);
-    expect(tokenize("1e3")).toEqual([{ type: "NUMBER", value: "1e3" }]);
-  });
-
-  test("debug formula token", () => {
-    expect(tokenize("=?1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "DEBUGGER", value: "?" },
-      { type: "NUMBER", value: "1" },
-    ]);
-  });
-  test("String", () => {
-    expect(tokenize('"hello"')).toEqual([{ type: "STRING", value: '"hello"' }]);
-    expect(tokenize("'hello'")).toEqual([{ type: "SYMBOL", value: "'hello'" }]);
-    expect(tokenize("'hello")).toEqual([{ type: "UNKNOWN", value: "'hello" }]);
-    expect(tokenize('"he\\"l\\"lo"')).toEqual([{ type: "STRING", value: '"he\\"l\\"lo"' }]);
-    expect(tokenize("\"hel'l'o\"")).toEqual([{ type: "STRING", value: "\"hel'l'o\"" }]);
-    expect(tokenize('"hello""test"')).toEqual([
-      { type: "STRING", value: '"hello"' },
-      { type: "STRING", value: '"test"' },
-    ]);
-  });
-
-  test.each(['"hello', `"hello'`, '"hello\\"'])("String without closing double quotes", (str) => {
-    expect(tokenize(str)).toEqual([{ type: "STRING", value: str }]);
-  });
-
-  test("Function token", () => {
-    expect(tokenize("SUM")).toEqual([{ type: "FUNCTION", value: "SUM" }]);
-    expect(tokenize("RAND")).toEqual([{ type: "FUNCTION", value: "RAND" }]);
-    expect(tokenize("rand")).toEqual([{ type: "FUNCTION", value: "rand" }]);
-  });
-
-  test("Function token with point", () => {
-    expect(tokenize("CEILING.MATH")).toEqual([{ type: "FUNCTION", value: "CEILING.MATH" }]);
-    expect(tokenize("ceiling.math")).toEqual([{ type: "FUNCTION", value: "ceiling.math" }]);
-  });
-
-  test("Boolean", () => {
-    expect(tokenize("true")).toEqual([{ type: "SYMBOL", value: "true" }]);
-    expect(tokenize("false")).toEqual([
-      {
-        type: "SYMBOL",
-        value: "false",
-      },
-    ]);
-    expect(tokenize("=AND(true,false)")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "FUNCTION", value: "AND" },
-      { type: "LEFT_PAREN", value: "(" },
-      { type: "SYMBOL", value: "true" },
-      { type: "COMMA", value: "," },
-      { type: "SYMBOL", value: "false" },
-      { type: "RIGHT_PAREN", value: ")" },
-    ]);
-    expect(tokenize("=trueee")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "trueee" },
-    ]);
-  });
-
-  test("$references", () => {
-    expect(tokenize("=$A$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "$A$1" },
-    ]);
-    expect(tokenize("=C$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "C$1" },
-    ]);
-    expect(tokenize("=$C1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "$C1" },
-    ]);
-  });
-
-  test("reference and sheets", () => {
-    expect(tokenize("=Sheet1!A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet1!A1" },
-    ]);
-    expect(tokenize("='Sheet1'!A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'Sheet1'!A1" },
-    ]);
-    expect(tokenize("='Aryl Nibor Xela Nalim'!A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'Aryl Nibor Xela Nalim'!A1" },
-    ]);
-    expect(tokenize("=Sheet1!$A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet1!$A1" },
-    ]);
-    expect(tokenize("=Sheet1!A$1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "Sheet1!A$1" },
-    ]);
-    expect(tokenize("='a '' b'!A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "SYMBOL", value: "'a '' b'!A1" },
-    ]);
-
-    // note the missing ' in the following test:
-    expect(tokenize("='Sheet1!A1")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "UNKNOWN", value: "'Sheet1!A1" },
-    ]);
-  });
-
-  test("Unknown characters", () => {
-    expect(tokenize("=ù4")).toEqual([
-      { type: "OPERATOR", value: "=" },
-      { type: "UNKNOWN", value: "ù" },
-      { type: "NUMBER", value: "4" },
-    ]);
-  });
-});

package/tests/functions/arguments_test.ts

@@ -1,141 +0,0 @@
-import { args } from "../../src/functions/arguments";
-
-describe("args", () => {
-  test("various", () => {
-    expect(args(``)).toEqual([]);
-    expect(args(`test (number) some number`)).toEqual([
-      {
-        type: ["NUMBER"],
-        description: "some number",
-        name: "test",
-      },
-    ]);
-
-    expect(
-      args(`
-       test (number) some number
-       test2 (number) some other number
-      `)
-    ).toEqual([
-      {
-        type: ["NUMBER"],
-        description: "some number",
-        name: "test",
-      },
-      {
-        type: ["NUMBER"],
-        description: "some other number",
-        name: "test2",
-      },
-    ]);
-  });
-
-  test("empty description", () => {
-    expect(args(`test (number)`)).toEqual([
-      {
-        type: ["NUMBER"],
-        name: "test",
-        description: "",
-      },
-    ]);
-  });
-
-  test("default number value", () => {
-    expect(args(`test (number,default=10) descr`)).toEqual([
-      {
-        type: ["NUMBER"],
-        name: "test",
-        description: "descr",
-        default: 10,
-      },
-    ]);
-  });
-
-  test("default string value", () => {
-    expect(args(`test (number,default="asdf") descr`)).toEqual([
-      {
-        type: ["NUMBER"],
-        name: "test",
-        description: "descr",
-        default: "asdf",
-      },
-    ]);
-  });
-
-  test("with parenthesis in the description", () => {
-    expect(args(`test (number) descr( hahaha )`)).toEqual([
-      {
-        type: ["NUMBER"],
-        name: "test",
-        description: "descr( hahaha )",
-      },
-    ]);
-  });
-
-  test("does not care if lower or uppercase", () => {
-    expect(args(`test (NUMBER)`)).toEqual([
-      {
-        type: ["NUMBER"],
-        name: "test",
-        description: "",
-      },
-    ]);
-  });
-
-  test("accept all basic types", () => {
-    expect(args(`test (boolean)`)[0].type).toEqual(["BOOLEAN"]);
-    expect(args(`test (any)`)[0].type).toEqual(["ANY"]);
-    expect(args(`test (NumBer)`)[0].type).toEqual(["NUMBER"]);
-    expect(args(`test (string)`)[0].type).toEqual(["STRING"]);
-  });
-
-  test("accept all range types", () => {
-    expect(args(`test (range)`)[0].type).toEqual(["RANGE"]);
-    expect(args(`test (range<any>)`)[0].type).toEqual(["RANGE"]);
-    expect(args(`test (range<boolean>)`)[0].type).toEqual(["RANGE<BOOLEAN>"]);
-    expect(args(`test (range<number>)`)[0].type).toEqual(["RANGE<NUMBER>"]);
-    expect(args(`test (range<string>)`)[0].type).toEqual(["RANGE<STRING>"]);
-  });
-
-  test("accept multiple types", () => {
-    expect(args(`test (boolean,string)`)[0].type).toEqual(["BOOLEAN", "STRING"]);
-    expect(args(`test (string,any)`)[0].type).toEqual(["STRING", "ANY"]);
-  });
-
-  test("accept optional flag", () => {
-    expect(args(`test (boolean,optional)`)).toEqual([
-      {
-        description: "",
-        name: "test",
-        type: ["BOOLEAN"],
-        optional: true,
-      },
-    ]);
-    expect(args(`test (boolean,optional,string)`)).toEqual([
-      {
-        description: "",
-        name: "test",
-        type: ["BOOLEAN", "STRING"],
-        optional: true,
-      },
-    ]);
-  });
-  test("accept repeating flag", () => {
-    expect(args(`test (boolean,repeating)`)).toEqual([
-      {
-        description: "",
-        name: "test",
-        type: ["BOOLEAN"],
-        repeating: true,
-      },
-    ]);
-    expect(args(`test (boolean,repeating,number)`)).toEqual([
-      {
-        description: "",
-        name: "test",
-        type: ["BOOLEAN", "NUMBER"],
-        repeating: true,
-      },
-    ]);
-  });
-});