@odoo/o-spreadsheet 1.0.1

package/tests/functions/functions_test.ts

@@ -0,0 +1,53 @@
+import { Model } from "../../src";
+import { args, functionRegistry } from "../../src/functions/index";
+import { evaluateCell, getCell } from "../helpers";
+
+describe("addFunction", () => {
+  test("can add a function", () => {
+    const val = evaluateCell("A1", { A1: "=DOUBLEDOUBLE(3)" });
+    expect(val).toBe("#BAD_EXPR");
+    functionRegistry.add("DOUBLEDOUBLE", {
+      description: "Double the first argument",
+      compute: (arg: number) => (2 * arg) as any,
+      args: args(`number (number) my number`),
+      returns: ["NUMBER"],
+    });
+    expect(evaluateCell("A1", { A1: "=DOUBLEDOUBLE(3)" })).toBe(6);
+  });
+
+  test("Can use a custom evaluation context in a function", () => {
+    const model = new Model(
+      {},
+      {
+        evalContext: {
+          coucou: "Raoul",
+        },
+      }
+    );
+    functionRegistry.add("GETCOUCOU", {
+      description: "Get coucou's name",
+      compute: function () {
+        return (this as any).coucou;
+      },
+      args: args(``),
+      returns: ["STRING"],
+    });
+    model.dispatch("SET_VALUE", { xc: "A1", text: "=GETCOUCOU()" });
+    expect(getCell(model, "A1")!.value).toBe("Raoul");
+  });
+
+  test("Can use a getter in a function", () => {
+    const model = new Model();
+    functionRegistry.add("GETNUMBERCOLS", {
+      description: "Get the number of columns",
+      compute: function () {
+        return (this as any).getters.getNumberCols(this.getters.getActiveSheet());
+      },
+      args: args(``),
+      returns: ["STRING"],
+    });
+    expect(evaluateCell("A1", { A1: "=GETNUMBERCOLS()" })).toBe(
+      model.getters.getNumberCols(model.getters.getActiveSheet())
+    );
+  });
+});

package/tests/functions/helper_test.ts

@@ -0,0 +1,98 @@
+import {
+  dichotomicPredecessorSearch,
+  dichotomicSuccessorSearch,
+} from "../../src/functions/helpers";
+
+describe("Function helpers", () => {
+  describe("dichotomicPredecessorSearch", () => {
+    test("with numbers only", () => {
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 4], 0)).toBe(0);
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 4], 4)).toBe(4);
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 4], 2)).toBe(2);
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 4], 22)).toBe(4);
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 4], -22)).toBe(-1);
+      expect(dichotomicPredecessorSearch([0, 1, 2, 3, 3], 3)).toBe(4);
+    });
+
+    test("with strings only", () => {
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "0")).toBe(0);
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "4")).toBe(4);
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "2")).toBe(2);
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "22")).toBe(2);
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "9")).toBe(4);
+      expect(dichotomicPredecessorSearch(["0", "1", "2", "3", "4"], "-22")).toBe(-1);
+      expect(dichotomicPredecessorSearch(["0", "1", "3", "3", "4"], "3")).toBe(3);
+    });
+
+    test("search number in strings and numbers", () => {
+      expect(dichotomicPredecessorSearch([0, "a", "a", "a", "a"], 0)).toBe(0);
+      expect(dichotomicPredecessorSearch(["a", "a", "a", "a", 0], 0)).toBe(4);
+      expect(dichotomicPredecessorSearch(["a", "a", 0, "a", "a"], 0)).toBe(2);
+      expect(dichotomicPredecessorSearch(["a", "a", "a", "a", "a"], 0)).toBe(-1);
+      expect(dichotomicPredecessorSearch(["0", "0", "a", 0, "0"], 0)).toBe(3);
+    });
+
+    test("search string in strings and numbers", () => {
+      const u = undefined;
+      expect(dichotomicPredecessorSearch(["a", u, u, u, u], "a")).toBe(0);
+      expect(dichotomicPredecessorSearch([u, u, u, u, "a"], "a")).toBe(4);
+      expect(dichotomicPredecessorSearch([u, u, "a", u, u], "a")).toBe(2);
+      expect(dichotomicPredecessorSearch([u, u, u, u, u], "a")).toBe(-1);
+      expect(dichotomicPredecessorSearch([u, "0", u, u, u], "0")).toBe(1);
+    });
+
+    test("search string in strings and numbers", () => {
+      expect(dichotomicPredecessorSearch(["a", 0, 0, 0, 0], "a")).toBe(0);
+      expect(dichotomicPredecessorSearch([0, 0, 0, 0, "a"], "a")).toBe(4);
+      expect(dichotomicPredecessorSearch([0, 0, "a", 0, 0], "a")).toBe(2);
+      expect(dichotomicPredecessorSearch([0, 0, 0, 0, 0], "a")).toBe(-1);
+      expect(dichotomicPredecessorSearch([0, "0", 0, 0, 0], "0")).toBe(1);
+    });
+  });
+
+  describe("dichotomicSuccessorSearch", () => {
+    test("with numbers only", () => {
+      expect(dichotomicSuccessorSearch([4, 3, 2, 1, 0], 4)).toBe(0);
+      expect(dichotomicSuccessorSearch([4, 3, 2, 1, 0], 0)).toBe(4);
+      expect(dichotomicSuccessorSearch([4, 3, 2, 1, 0], 2)).toBe(2);
+      expect(dichotomicSuccessorSearch([4, 3, 2, 1, 0], 22)).toBe(-1);
+      expect(dichotomicSuccessorSearch([4, 3, 2, 1, 0], -22)).toBe(4);
+      expect(dichotomicSuccessorSearch([3, 3, 2, 1, 0], 3)).toBe(0);
+    });
+
+    test("with strings only", () => {
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "0")).toBe(4);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "4")).toBe(0);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "2")).toBe(2);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "22")).toBe(1);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "9")).toBe(-1);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "-22")).toBe(4);
+      expect(dichotomicSuccessorSearch(["4", "3", "2", "1", "0"], "3")).toBe(1);
+    });
+
+    test("search number in strings and numbers", () => {
+      expect(dichotomicSuccessorSearch([0, "a", "a", "a", "a"], 0)).toBe(0);
+      expect(dichotomicSuccessorSearch(["a", "a", "a", "a", 0], 0)).toBe(4);
+      expect(dichotomicSuccessorSearch(["a", "a", 0, "a", "a"], 0)).toBe(2);
+      expect(dichotomicSuccessorSearch(["a", "a", "a", "a", "a"], 0)).toBe(-1);
+      expect(dichotomicSuccessorSearch(["0", "0", "a", 0, "0"], 0)).toBe(3);
+    });
+
+    test("search string in strings and numbers", () => {
+      const u = undefined;
+      expect(dichotomicSuccessorSearch(["a", u, u, u, u], "a")).toBe(0);
+      expect(dichotomicSuccessorSearch([u, u, u, u, "a"], "a")).toBe(4);
+      expect(dichotomicSuccessorSearch([u, u, "a", u, u], "a")).toBe(2);
+      expect(dichotomicSuccessorSearch([u, u, u, u, u], "a")).toBe(-1);
+      expect(dichotomicSuccessorSearch([u, "0", u, u, u], "0")).toBe(1);
+    });
+
+    test("search string in strings and numbers", () => {
+      expect(dichotomicSuccessorSearch(["a", 0, 0, 0, 0], "a")).toBe(0);
+      expect(dichotomicSuccessorSearch([0, 0, 0, 0, "a"], "a")).toBe(4);
+      expect(dichotomicSuccessorSearch([0, 0, "a", 0, 0], "a")).toBe(2);
+      expect(dichotomicSuccessorSearch([0, 0, 0, 0, 0], "a")).toBe(-1);
+      expect(dichotomicSuccessorSearch([0, "0", 0, 0, 0], "0")).toBe(1);
+    });
+  });
+});

package/tests/functions/module_database_test.ts

@@ -0,0 +1,311 @@
+import { evaluateGrid } from "../helpers";
+
+describe("database", () => {
+  // prettier-ignore
+  const database = {
+        A1:  "NAME"          , B1:  "FILM"                , C1:  "YEAR", D1:  "SCORE", 
+        A2:  "Jean Rochefort", B2:  "Un éléphant ça ..."  , C2:  "1976", D2:  "0.71" , 
+        A3:  "Jean Benguigui", B3:  "Bufffet froid"       , C3:  "1976", D3:  "0.75" , 
+        A4:  "Jean Dujardin" , B4:  "The Artist"          , C4:  "2011", D4:  "0.95" , 
+        A5:  "Jean Ferrat"   , B5:  "Vivre sa vie"        , C5:  "1962", D5:  "0.8"  ,
+        A6:  "Jean Gabin"    , B6:  "Le jour se lève"     , C6:  "1939", D6:  "0.78" , 
+        A7:  "Jean Marais"   , B7:  "Fantômas"            , C7:  "1964", D7:  "0.7"  ,
+        A8:  "Jean Reno"     , B8:  "Le Grand Bleu"       , C8:  "1988", D8:  "0.76" , 
+        A9:  "Jean Rochefort", B9:  "Le Mari de la coi...", C9:  "1990", D9:  "0.73" , 
+        A10: "Jean Benguigui", B10: "Coco"                , C10: "2009", D10: "0.28" , 
+        A11: "Jean Reno"     , B11: "Léon"                , C11: "1994", D11: "0.75" , 
+        A12: "Jean Lassalle" , 
+        A13: "Jean Benguigui", B13: "Astérix et Obélix...", C13: "2002", D13: "0.86" , 
+        A14: "Jean Benguigui", B14: "Les Fugitifs"        , C14: "1986", D14: "0.64" , 
+        A15: "Jean Reno"     , B15: "Les Visiteurs"       , C15: "1993", D15: "0.71" , 
+        A16: "Jean Gabin"    , B16: "La Bête humaine"     , C16: "1938", D16: "0.76" , 
+        A17: "Jean Ferrat"   , B17: "La Vieille dame ..." , C17: "1965", D17: "0.7" 
+    }
+
+  test("DCOUNT: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const gridDcount = {
+          A20: "YEAR", 
+          A21: "1976", B21: '=DCOUNT(A1:D17, "YEAR", A20:A21)',
+          
+          B24: '=DCOUNT(A1:D17, "YEAR", A23:A24)',
+
+          A27: "1976", B27: '=DCOUNT(A1:D17, "YEAR", A26:A27)',
+
+          A29: "YEAR", 
+                       B30: '=DCOUNT(A1:D17, "YEAR", A29:A30)',
+
+          A32: "TEST", 
+          A33: "2"   , B33: '=DCOUNT(A1:D17, "YEAR", A32:A33)',
+
+          A35: "TEST", 
+                       B36: '=DCOUNT(A1:D17, "YEAR", A35:A36)',
+
+          A39: "2"   , B39: '=DCOUNT(A1:D17, "YEAR", A38:A39)',
+
+          A41: "FILM", 
+          A42: "Léon", B42: '=DCOUNT(A1:D17, "FILM", A41:A42)',
+
+          A44: "year"  , B44: "year" ,
+          A45: "<>1965", B45: ">1940", C45: '=DCOUNT(A1:D17, "YEAR", A44:B45)',
+
+          A47: "NAME"  , 
+          A48: "Jean R", B48: '=DCOUNT(A1:D17, "YEAR", A47:A48)',
+
+          A50: "NAME"   , 
+          A51: "Jean Re", B51: '=DCOUNT(A1:D17, "YEAR", A50:A51)',
+
+          A53: "NAME"  , 
+          A54: "Jean R", B54: '=DCOUNT(A1:D17, C1, A53:A54)',
+
+          A56: "NAME"  , 
+          A57: "Jean R", B57: '=DCOUNT(A1:D17, 3, A56:A57)',
+
+          A59: "1"     , 
+          A60: "Jean R", B60: '=DCOUNT(A1:D17, "YEAR", A59:A60)',
+          
+          A62: "SCORE", B62: "SCORE",
+          A63: "0.71" , B63: "0.7"  , C63: '=DCOUNT(A1:D17, "YEAR", A62:B63)',
+          
+          A65: "SCORE",
+          A66: "0.71" , 
+          A67: "0.7"  , B67: '=DCOUNT(A1:D17, "YEAR", A65:A67)',
+
+          A69: "SCORE", 
+          A70: ">0.7" , B70: '=DCOUNT(A1:D17, "YEAR", A69:A70)',
+
+          A72: "SCORE",
+          A73: ">0.7" , 
+          A74: ">0.71", B74: '=DCOUNT(A1:D17, "YEAR", A72:A74)',
+
+          A76: "NAME"  , 
+          A77: "JEAN R", B77: '=DCOUNT(A1:D17, 4.9, A76:A77)',
+
+          A79: "SCORE", B79: "YEAR"
+                      , B80: "1976",
+          A81: "0.7"  ,              C81: '=DCOUNT(A1:D17, "YEAR", A79:B81)',
+          
+          A83: "SCORE", B83: "TEST"
+                      , B84: "1976",
+          A85: "0.7"  ,              C85: '=DCOUNT(A1:D17, "YEAR", A83:B85)',
+           
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...gridDcount });
+
+    expect(gridResult.B21).toBe(2);
+    expect(gridResult.B24).toBe(15);
+    expect(gridResult.B27).toBe(0);
+    expect(gridResult.B30).toBe(15);
+    expect(gridResult.B33).toBe(0);
+    expect(gridResult.B36).toBe(15);
+    expect(gridResult.B39).toBe(0);
+    expect(gridResult.B42).toBe(0);
+    expect(gridResult.C45).toBe(12);
+    expect(gridResult.B48).toBe(5);
+    expect(gridResult.B51).toBe(3);
+    expect(gridResult.B54).toBe(5);
+    expect(gridResult.B57).toBe(5);
+    expect(gridResult.B60).toBe(0);
+    expect(gridResult.C63).toBe(0);
+    expect(gridResult.B67).toBe(4);
+    expect(gridResult.B70).toBe(11);
+    expect(gridResult.B74).toBe(11);
+    expect(gridResult.B77).toBe(5);
+    expect(gridResult.C81).toBe(4);
+    expect(gridResult.C85).toBe(2);
+  });
+
+  // prettier-ignore
+  const criteria = {
+        F1: "YEAR", 
+        F2: "1976",
+        
+        F4: "FILM",
+        F5: "Léon",
+
+        F7: "SCORE",
+        F8: ">0.7",
+        F9: "0.28",
+
+        F11: "SCORE", G11: "YEAR",
+                      G12: "1976",
+        F13: "0.7"  , G13: "1964",
+    }
+
+  test("DAVERAGE: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DAVERAGE(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DAVERAGE(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DAVERAGE(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DAVERAGE(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(0.73);
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBe(1981.5);
+    expect(gridResult.A23).toBe(1972);
+  });
+
+  test("DCOUNTA: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DCOUNTA(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DCOUNTA(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DCOUNTA(A1:D17, "NAME", F7:F9)',            
+          A23: '=DCOUNTA(A1:D17, "NAME", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(2);
+    expect(gridResult.A21).toBe(1);
+    expect(gridResult.A22).toBe(12);
+    expect(gridResult.A23).toBe(3);
+  });
+
+  test("DGET: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DGET(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DGET(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DGET(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DGET(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
+    expect(gridResult.A23).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
+  });
+
+  test("DMAX: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DMAX(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DMAX(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DMAX(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DMAX(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(0.75);
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBe(2011);
+    expect(gridResult.A23).toBe(1976);
+  });
+
+  test("DMIN: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DMIN(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DMIN(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DMIN(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DMIN(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(0.71);
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBe(1938);
+    expect(gridResult.A23).toBe(1964);
+  });
+
+  test("DPRODUCT: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DPRODUCT(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DPRODUCT(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DPRODUCT(A1:D17, "SCORE", F7:F9)',            
+          A23: '=DPRODUCT(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(0.5325);
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBeCloseTo(0.01707, 5);
+    expect(gridResult.A23).toBe(7668587264);
+  });
+
+  test("DSTDEV: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DSTDEV(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DSTDEV(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DSTDEV(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DSTDEV(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBeCloseTo(0.02828, 5);
+    expect(gridResult.A21).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
+    expect(gridResult.A22).toBeCloseTo(24.47448, 5);
+    expect(gridResult.A23).toBeCloseTo(6.9282, 5);
+  });
+
+  test("DSTDEVP: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DSTDEVP(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DSTDEVP(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DSTDEVP(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DSTDEVP(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBeCloseTo(0.02);
+    expect(gridResult.A21).toBe(0);
+    expect(gridResult.A22).toBeCloseTo(23.43253, 5);
+    expect(gridResult.A23).toBeCloseTo(5.65685, 5);
+  });
+
+  test("DSUM: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DSUM(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DSUM(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DSUM(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DSUM(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBe(1.46);
+    expect(gridResult.A21).toBe(0.75);
+    expect(gridResult.A22).toBe(23778);
+    expect(gridResult.A23).toBe(5916);
+  });
+
+  test("DVAR: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DVAR(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DVAR(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DVAR(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DVAR(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBeCloseTo(0.0008, 4);
+    expect(gridResult.A21).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
+    expect(gridResult.A22).toBe(599);
+    expect(gridResult.A23).toBe(48);
+  });
+
+  test("DVARP: functional tests on cell arguments", () => {
+    // prettier-ignore
+    const grid = {
+          A20: '=DVARP(A1:D17, "SCORE", F1:F2)',            
+          A21: '=DVARP(A1:D17, "SCORE", F4:F5)',            
+          A22: '=DVARP(A1:D17, "YEAR", F7:F9)',            
+          A23: '=DVARP(A1:D17, "YEAR", F11:G13)',            
+        };
+
+    const gridResult = evaluateGrid({ ...database, ...criteria, ...grid });
+    expect(gridResult.A20).toBeCloseTo(0.0004, 4);
+    expect(gridResult.A21).toBe(0);
+    expect(gridResult.A22).toBeCloseTo(549.08333, 5);
+    expect(gridResult.A23).toBe(32);
+  });
+});