[IMP] evaluation: formula results can be used as reference

Enabling the reuse of functions returning references as arguments
in functions expecting references.

Task: 5428577

Author: laa-odoo

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

@@ -57,6 +57,10 @@ const expectNumberValueError = (value: string) =>
     value
   );
 
+export const expectReferenceError = _t(
+  "The function [[FUNCTION_NAME]] expects a reference to a cell or range."
+);
+
 export const expectNumberRangeError = (lowerBound: number, upperBound: number, value: number) =>
   _t(
     "The function [[FUNCTION_NAME]] expects a number value between %s and %s inclusive, but receives %s.",

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

@@ -1,11 +1,10 @@
-import { getFullReference, setXcToFixedReferenceType, splitReference } from "../helpers/references";
+import { toXC } from "../helpers/coordinates";
 import { _t } from "../translation";
-import { CellValueType } from "../types/cells";
 import { CellErrorType, EvaluationError } from "../types/errors";
 import { AddFunctionDescription } from "../types/functions";
-import { FunctionResultObject, Matrix, Maybe } from "../types/misc";
+import { Arg, FunctionResultObject, Maybe } from "../types/misc";
 import { arg } from "./arguments";
-import { isEvaluationError, toString } from "./helpers";
+import { isEvaluationError, toMatrix, toString } from "./helpers";
 
 // -----------------------------------------------------------------------------
 // CELL
@@ -35,45 +34,43 @@ export const CELL = {
   description: _t("Gets information about a cell."),
   args: [
     arg("info_type (string)", _t("The type of information requested."), CELL_INFO_TYPES),
-    arg("reference (meta, range<meta>)", _t("The reference to the cell.")),
+    arg("reference (any, range<any>)", _t("The reference to the cell.")),
   ],
-  compute: function (info: Maybe<FunctionResultObject>, reference: Matrix<{ value: string }>) {
+  compute: function (info: Maybe<FunctionResultObject>, reference: Arg) {
     const _info = toString(info).toLowerCase();
     if (!CELL_INFO_TYPES.map((type) => type.value).includes(_info)) {
       return new EvaluationError(
         _t("The info_type should be one of %s.", CELL_INFO_TYPES.join(", "))
       );
     }
 
-    const sheetId = this.__originSheetId;
-    const _reference = reference[0][0].value;
-    let { sheetName, xc } = splitReference(_reference);
-    // only put the sheet name if the referenced range is in another sheet than the cell the formula is on
-    sheetName = sheetName === this.getters.getSheetName(sheetId) ? undefined : sheetName;
-    const fixedRef = getFullReference(sheetName, setXcToFixedReferenceType(xc, "colrow"));
-    const range = this.getters.getRangeFromSheetXC(sheetId, fixedRef);
+    const firstReference = toMatrix(reference)[0][0];
+    const position = firstReference.position;
+    if (position === undefined) {
+      return new EvaluationError(_t("The reference is invalid."));
+    }
 
     switch (_info) {
       case "address":
-        return this.getters.getRangeString(range, sheetId);
+        const sheetName =
+          this.__originSheetId === position.sheetId
+            ? ""
+            : this.getters.getSheetName(position.sheetId) + "!";
+        return sheetName + toXC(position.col, position.row, { colFixed: true, rowFixed: true });
       case "col":
-        return range.zone.left + 1;
+        return position.col + 1;
       case "contents": {
-        const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
-        return this.getters.getEvaluatedCell(position).value;
+        return firstReference.value;
       }
       case "format": {
-        const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
-        return this.getters.getEvaluatedCell(position).format || "";
+        return firstReference.format || "";
       }
       case "row":
-        return range.zone.top + 1;
+        return position.row + 1;
       case "type": {
-        const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
-        const type = this.getters.getEvaluatedCell(position).type;
-        if (type === CellValueType.empty) {
+        if (firstReference.type === "empty") {
           return "b"; // blank
-        } else if (type === CellValueType.text) {
+        } else if (firstReference.type === "text") {
           return "l"; // label
         } else {
           return "v"; // value

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

@@ -1,13 +1,12 @@
 import { getPivotTooBigErrorMessage } from "../components/translations_terms";
 import { PIVOT_MAX_NUMBER_OF_CELLS } from "../constants";
-import { getFullReference, splitReference } from "../helpers/";
-import { toCartesian, toXC } from "../helpers/coordinates";
+import { getFullReference } from "../helpers/";
+import { toXC } from "../helpers/coordinates";
 import { isFormula, range } from "../helpers/misc";
 import {
   addAlignFormatToPivotHeader,
   getPivotStyleFromFnArgs,
 } from "../helpers/pivot/pivot_helpers";
-import { toZone } from "../helpers/zones";
 import { _t } from "../translation";
 import {
   CellErrorType,
@@ -16,7 +15,7 @@ import {
   NotAvailableError,
 } from "../types/errors";
 import { AddFunctionDescription } from "../types/functions";
-import { Arg, FunctionResultObject, Matrix, Maybe, UID, Zone } from "../types/misc";
+import { Arg, FunctionResultObject, Matrix, Maybe, Zone } from "../types/misc";
 import { arg } from "./arguments";
 import { expectNumberGreaterThanOrEqualToOne } from "./helper_assert";
 import {
@@ -28,8 +27,8 @@ import {
 import {
   dichotomicSearch,
   expectNumberRangeError,
+  expectReferenceError,
   generateMatrix,
-  isEvaluationError,
   linearSearch,
   LinearSearchMode,
   strictToInteger,
@@ -134,15 +133,15 @@ export const COLUMN = {
   description: _t("Column number of a specified cell."),
   args: [
     arg(
-      "cell_reference (meta, range<meta>, default='this cell')",
+      "cell_reference (any, range<any>, default='this cell')",
       _t(
         "The cell whose column number will be returned. Column A corresponds to 1. By default, the function use the cell in which the formula is entered."
       )
     ),
   ],
-  compute: function (cellReference: Matrix<{ value: string }> | undefined) {
+  compute: function (cellReference: Arg) {
     if (cellReference === undefined) {
-      if (this.__originCellPosition?.col === undefined) {
+      if (this.__originCellPosition === undefined) {
         return new EvaluationError(
           _t(
             "In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter."
@@ -151,20 +150,20 @@ export const COLUMN = {
       }
       return this.__originCellPosition.col + 1;
     }
-    if (cellReference[0][0] === undefined) {
+    const _cellReference = toMatrix(cellReference);
+    const firstCell = _cellReference[0][0];
+    if (firstCell === undefined) {
+      // to do: should work with ranges out of bounds
       return new EvaluationError(_t("The range is out of bounds."));
     }
-    if (cellReference[0][0].value === CellErrorType.InvalidReference) {
-      return cellReference[0][0]; // return the same error
+    if (firstCell.position === undefined) {
+      return new InvalidReferenceError(expectReferenceError);
     }
-    const left = this.getters.getRangeFromSheetXC(
-      this.getters.getActiveSheetId(),
-      cellReference[0][0].value
-    ).zone.left;
-    if (cellReference.length === 1) {
+    const left = firstCell.position.col;
+    if (_cellReference.length === 1) {
       return left + 1;
     }
-    return generateMatrix(cellReference.length, 1, (col, row) => ({ value: left + col + 1 }));
+    return generateMatrix(_cellReference.length, 1, (col) => ({ value: left + col + 1 }));
   },
   isExported: true,
 } satisfies AddFunctionDescription;
@@ -528,13 +527,13 @@ export const ROW = {
   description: _t("Row number of a specified cell."),
   args: [
     arg(
-      "cell_reference (meta, range<meta>, default='this cell')",
+      "cell_reference (any, range<any>, default='this cell')",
       _t(
         "The cell whose row number will be returned. By default, this function uses the cell in which the formula is entered."
       )
     ),
   ],
-  compute: function (cellReference: Matrix<{ value: string }> | undefined) {
+  compute: function (cellReference: Arg) {
     if (cellReference === undefined) {
       if (this.__originCellPosition?.row === undefined) {
         return new EvaluationError(
@@ -545,20 +544,20 @@ export const ROW = {
       }
       return this.__originCellPosition.row + 1;
     }
-    if (cellReference[0][0] === undefined) {
+    const _cellReference = toMatrix(cellReference);
+    const firstCell = _cellReference[0][0];
+    if (firstCell === undefined) {
+      // to do: should work with ranges out of bounds
       return new EvaluationError(_t("The range is out of bounds."));
     }
-    if (cellReference[0][0].value === CellErrorType.InvalidReference) {
-      return cellReference[0][0]; // return the same error
+    if (firstCell.position === undefined) {
+      return new InvalidReferenceError(expectReferenceError);
     }
-    const top = this.getters.getRangeFromSheetXC(
-      this.getters.getActiveSheetId(),
-      cellReference[0][0].value
-    ).zone.top;
-    if (cellReference[0].length === 1) {
+    const top = firstCell.position.row;
+    if (_cellReference[0].length === 1) {
       return top + 1;
     }
-    return generateMatrix(1, cellReference[0].length, (col, row) => ({ value: top + row + 1 }));
+    return generateMatrix(1, _cellReference[0].length, (col, row) => ({ value: top + row + 1 }));
   },
   isExported: true,
 } satisfies AddFunctionDescription;
@@ -1006,7 +1005,7 @@ export const OFFSET = {
   ),
   args: [
     arg(
-      "cell_reference (meta, range<meta>)",
+      "cell_reference (any, range<any>)",
       _t("The starting point from which to count the offset rows and columns.")
     ),
     arg("offset_rows (number)", _t("The number of rows to offset by.")),
@@ -1021,26 +1020,29 @@ export const OFFSET = {
     ),
   ],
   compute: function (
-    cellReference: Matrix<{ value: string }>,
+    cellReference: Arg,
     offsetRows: Maybe<FunctionResultObject>,
     offsetColumns: Maybe<FunctionResultObject>,
     height: Maybe<FunctionResultObject>,
     width: Maybe<FunctionResultObject>
   ) {
-    if (isEvaluationError(cellReference[0][0].value)) {
-      return cellReference[0][0];
+    if (cellReference === undefined) {
+      return new InvalidReferenceError(expectReferenceError);
     }
+    const _cellReference = toMatrix(cellReference);
+    const firstCell = _cellReference[0][0];
 
-    const ref0 = cellReference[0][0].value;
-    if (!ref0) {
-      return new EvaluationError(
-        "In this context, the function OFFSET needs to have a cell or range in parameter."
-      );
+    if (firstCell === undefined) {
+      // to do: should work with ranges out of bounds
+      return new EvaluationError(_t("The range is out of bounds."));
     }
-    const zone = toZone(ref0);
 
-    let offsetHeight = cellReference[0].length;
-    let offsetWidth = cellReference.length;
+    if (firstCell.position === undefined) {
+      return new InvalidReferenceError(expectReferenceError);
+    }
+
+    let offsetHeight = _cellReference[0].length;
+    let offsetWidth = _cellReference.length;
 
     if (height) {
       const _height = toNumber(height, this.locale);
@@ -1062,11 +1064,6 @@ export const OFFSET = {
       offsetWidth = _width;
     }
 
-    const { sheetName } = splitReference(ref0);
-
-    const sheetId =
-      (sheetName && this.getters.getSheetIdByName(sheetName)) || this.getters.getActiveSheetId();
-
     const _offsetRows = toNumber(offsetRows, this.locale);
     const _offsetColumns = toNumber(offsetColumns, this.locale);
 
@@ -1075,8 +1072,8 @@ export const OFFSET = {
       this.updateDependencies?.(originPosition);
     }
 
-    const startingCol = zone.left + _offsetColumns;
-    const startingRow = zone.top + _offsetRows;
+    const startingCol = firstCell.position.col + _offsetColumns;
+    const startingRow = firstCell.position.row + _offsetRows;
 
     if (startingCol < 0 || startingRow < 0) {
       return new InvalidReferenceError(_t("OFFSET evaluates to an out of bounds range."));
@@ -1089,6 +1086,7 @@ export const OFFSET = {
       bottom: startingRow + offsetHeight - 1,
     };
 
+    const sheetId = firstCell.position.sheetId;
     const range = this.getters.getRangeFromZone(sheetId, dependencyZone);
     if (range.invalidXc || range.invalidSheetName) {
       return new InvalidReferenceError();
@@ -1246,13 +1244,12 @@ export const TAKE = {
 
 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);
-    const sheetId: UID =
-      (sheetName && this.getters.getSheetIdByName(sheetName)) ?? this.__originSheetId;
-    const cell = this.getters.getCell({ sheetId, col, row });
+  args: [arg("cell_reference (any)", _t("A reference to a cell."))],
+  compute: function (cellReference: Maybe<FunctionResultObject>) {
+    if (cellReference?.position === undefined) {
+      return new InvalidReferenceError(expectReferenceError);
+    }
+    const cell = this.getters.getCell(cellReference.position);
     if (cell && isFormula(cell.content)) {
       return cell.content;
     } else {

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

@@ -1,9 +1,7 @@
-import { splitReference } from "../helpers";
-import { toZone } from "../helpers/zones";
 import { isSubtotalCell } from "../plugins/ui_feature/subtotal_evaluation";
 import { _t } from "../translation";
 import { EvaluatedCell } from "../types/cells";
-import { DivisionByZeroError, EvaluationError } from "../types/errors";
+import { DivisionByZeroError, EvaluationError, InvalidReferenceError } from "../types/errors";
 import { AddFunctionDescription } from "../types/functions";
 import {
   Arg,
@@ -18,6 +16,7 @@ import { assertNotZero } from "./helper_assert";
 import { countUnique, sum } from "./helper_math";
 import { getUnitMatrix } from "./helper_matrices";
 import {
+  expectReferenceError,
   generateMatrix,
   inferFormat,
   isDataNonEmpty,
@@ -26,6 +25,7 @@ import {
   strictToNumber,
   toBoolean,
   toInteger,
+  toMatrix,
   toNumber,
   toString,
   visitMatchingRanges,
@@ -1372,14 +1372,11 @@ export const SUBTOTAL = {
       ...subtotalFunctionOptionsExcludeHiddenRows,
     ]),
     arg(
-      "ref (meta, range<meta>, repeating)",
+      "ref (any, range<any>, repeating)",
       _t("Range or reference for which you want the subtotal.")
     ),
   ],
-  compute: function (
-    functionCode: Maybe<FunctionResultObject>,
-    ...refs: Matrix<{ value: string }>[]
-  ) {
+  compute: function (functionCode: Maybe<FunctionResultObject>, ...refs: Arg[]) {
     let code = toInteger(functionCode, this.locale);
     let acceptHiddenCells = true;
     if (code > 100) {
@@ -1395,20 +1392,20 @@ export const SUBTOTAL = {
     const evaluatedCellToKeep: EvaluatedCell[] = [];
 
     for (const ref of refs) {
-      const ref0 = ref[0][0];
-      const sheetName = splitReference(ref0.value).sheetName;
-      const sheetId = sheetName ? this.getters.getSheetIdByName(sheetName) : this.__originSheetId;
-
-      if (!sheetId) continue;
-      const { top, left } = toZone(ref0.value);
-      const right = left + ref.length - 1;
-      const bottom = top + ref[0].length - 1;
+      const _ref = toMatrix(ref);
+      const firstPosition = _ref[0][0]?.position;
+      if (firstPosition === undefined) {
+        return new InvalidReferenceError(expectReferenceError);
+      }
+      const right = firstPosition.col + _ref.length - 1;
+      const bottom = firstPosition.row + _ref[0].length - 1;
+      const sheetId = firstPosition.sheetId;
 
-      for (let row = top; row <= bottom; row++) {
+      for (let row = firstPosition.row; row <= bottom; row++) {
         if (this.getters.isRowFiltered(sheetId, row)) continue;
         if (!acceptHiddenCells && this.getters.isRowHiddenByUser(sheetId, row)) continue;
 
-        for (let col = left; col <= right; col++) {
+        for (let col = firstPosition.col; col <= right; col++) {
           const cell = this.getters.getCorrespondingFormulaCell({ sheetId, col, row });
           if (!cell || !isSubtotalCell(cell)) {
             evaluatedCellToKeep.push(this.getters.getEvaluatedCell({ sheetId, col, row }));