[IMP] functions: added TAKE functions

Task: 5231138

Author: matho-odoo

packages/o-spreadsheet-engine/src/functions/module_lookup.ts

@@ -1,7 +1,7 @@
 import { getPivotTooBigErrorMessage } from "../components/translations_terms";
 import { PIVOT_MAX_NUMBER_OF_CELLS } from "../constants";
 import { getFullReference, splitReference } from "../helpers/";
-import { toXC } from "../helpers/coordinates";
+import { toCartesian, toXC } from "../helpers/coordinates";
 import { range } from "../helpers/misc";
 import {
   addAlignFormatToPivotHeader,
@@ -11,7 +11,7 @@ import { toZone } from "../helpers/zones";
 import { _t } from "../translation";
 import { CellErrorType, EvaluationError, InvalidReferenceError } from "../types/errors";
 import { AddFunctionDescription } from "../types/functions";
-import { Arg, FunctionResultObject, Matrix, Maybe, Zone } from "../types/misc";
+import { Arg, FunctionResultObject, Matrix, Maybe, UID, Zone } from "../types/misc";
 import { arg } from "./arguments";
 import { expectNumberGreaterThanOrEqualToOne } from "./helper_assert";
 import {
@@ -1222,3 +1222,76 @@ export const ARRAYTOTEXT = {
   },
   isExported: true,
 } satisfies AddFunctionDescription;
+
+// -----------------------------------------------------------------------------
+// FORMULATEXT
+// -----------------------------------------------------------------------------
+
+export const FORMULATEXT = {
+  description: _t("Returns a formula as a string."),
+  args: [arg("cell_reference (meta)", _t("A reference to a cell."))],
+  compute: function (cellReference: { value: string }) {
+    const { sheetName, xc } = splitReference(cellReference.value);
+    const { col, row } = toCartesian(xc);
+    let sheetId: UID;
+    if (sheetName) {
+      //@ts-ignore
+      sheetId = this.getters.getSheetIdByName(sheetName);
+    } else {
+      sheetId = this.getters.getActiveSheetId();
+    }
+    const result = this.getters.getCell({ sheetId, col, row });
+    return result?.content || "";
+  },
+  isExported: true,
+} satisfies AddFunctionDescription;
+
+// -----------------------------------------------------------------------------
+// TAKE
+// -----------------------------------------------------------------------------
+
+export const TAKE = {
+  description: _t(
+    "Returns a specified number of contiguous rows or columns from the start or end of an array."
+  ),
+  args: [
+    arg("array (range)", _t("The array from which to take rows or columns.")),
+    arg(
+      "rows (number)",
+      _t("The number of rows to take. A negative value takes from the end of the array.")
+    ),
+    arg(
+      "columns (number, optional)",
+      _t("The number of columns to take. A negative value takes from the end of the array.")
+    ),
+  ],
+  compute: function (
+    array: Matrix<{ value: string }>,
+    rows: Maybe<FunctionResultObject>,
+    columns: Maybe<FunctionResultObject>
+  ) {
+    let _rows = toNumber(rows, this.locale);
+    let _columns = toNumber(columns, this.locale);
+    let result = array;
+    if (Math.abs(_columns) >= array.length || _columns === 0) {
+      _columns = array.length;
+    }
+    if (Math.abs(_rows) >= array[0].length) {
+      _rows = array[0].length;
+    }
+    if (_columns >= 0) {
+      result = result.slice(0, _columns);
+    } else {
+      result = result.slice(result.length + _columns, result.length);
+    }
+    for (let i = 0; i < result.length; i++) {
+      if (_rows >= 0) {
+        result[i] = result[i].slice(0, _rows);
+      } else {
+        result[i] = result[i].slice(result[i].length + _rows, result[i].length);
+      }
+    }
+    return result;
+  },
+  isExported: true,
+} satisfies AddFunctionDescription;

tests/functions/module_lookup.test.ts

@@ -2085,3 +2085,130 @@ describe("ARRAYTOTEXT formula", () => {
     expect(evaluateCell("D5", grid)).toBe("A1,,A2,B2");
   });
 });
+
+describe("TAKE formula", () => {
+  test("correct for one row", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,1)", E5: "", 
+    };
+    //prettier-ignore
+    const result = {
+      A1: "A1", B1: "B1", 
+      A2: "A2", B2: "B2", 
+                                    D5: "A1", E5: "B1",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("correct for -1 column", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,2,-1)",
+                                    D6: ""
+    };
+    //prettier-ignore
+    const result = {
+      A1: "A1", B1: "B1", 
+      A2: "A2", B2: "B2", 
+                                    D5: "B1",
+                                    D6: "B2"
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("correct for -1 row", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,-1)", E5: "", 
+    };
+    //prettier-ignore
+    const result = {
+      A1: "A1", B1: "B1", 
+      A2: "A2", B2: "B2", 
+                                    D5: "A2", E5: "B2",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("all rows if too much rows to take", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,3)", E5: "",
+                                    D6: "", E6: ""
+    };
+    //prettier-ignore
+    const result = {
+      A1: "A1", B1: "B1", 
+      A2: "A2", B2: "B2", 
+                                    D5: "A1", E5: "B1",
+                                    D6: "A2", E6: "B2",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("all columns if too much columns to take", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,2,3)", E5: "",
+                                    D6: "", E6: ""
+    };
+    const result = {
+      A1: "A1",
+      B1: "B1",
+      A2: "A2",
+      B2: "B2",
+      D5: "A1",
+      E5: "B1",
+      D6: "A2",
+      E6: "B2",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("all rows if too much rows to take in negative", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,-3)", E5: "",
+                                    D6: "", E6: ""
+    };
+    const result = {
+      A1: "A1",
+      B1: "B1",
+      A2: "A2",
+      B2: "B2",
+      D5: "A1",
+      E5: "B1",
+      D6: "A2",
+      E6: "B2",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+  test("all columns if too much columns to take in negative", () => {
+    //prettier-ignore
+    const grid = {
+      A1: "A1", B1: "B1",
+      A2: "A2", B2: "B2",
+                                    D5: "=TAKE(A1:B2,2,-3)", E5: "",
+                                    D6: "", E6: ""
+    };
+    const result = {
+      A1: "A1",
+      B1: "B1",
+      A2: "A2",
+      B2: "B2",
+      D5: "A1",
+      E5: "B1",
+      D6: "A2",
+      E6: "B2",
+    };
+    expect(evaluateGrid(grid)).toEqual(result);
+  });
+});