cell position metadata in evaluation

Author: hokolomopo

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

@@ -34,7 +34,7 @@ export function createComputeFunction(
       acceptToVectorize.push(!argDefinition.acceptMatrix);
     }
 
-    return applyVectorization(errorHandlingCompute.bind(this), args, acceptToVectorize);
+    return applyVectorization(this, errorHandlingCompute, args, acceptToVectorize);
   }
 
   function errorHandlingCompute(

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

@@ -11,7 +11,7 @@ import {
   NotAvailableError,
   errorTypes,
 } from "../types/errors";
-import { LookupCaches } from "../types/functions";
+import { EvalContext, LookupCaches } from "../types/functions";
 import { Locale } from "../types/locale";
 import {
   Arg,
@@ -499,6 +499,7 @@ type VectorArgType = "horizontal" | "vertical" | "matrix";
  *   as ranges and invoke this helper directly within your `compute` implementation.
  */
 export function applyVectorization(
+  evalCtx: EvalContext,
   formula: (...args: Arg[]) => Matrix<FunctionResultObject> | FunctionResultObject,
   args: Arg[],
   acceptToVectorize: boolean[] | undefined = undefined
@@ -541,7 +542,7 @@ export function applyVectorization(
 
   if (countVectorizedCol === 1 && countVectorizedRow === 1) {
     // either this function is not vectorized or it ends up with a 1x1 dimension
-    return formula(...args);
+    return formula.call(evalCtx, ...args);
   }
 
   const getArgOffset: (i: number, j: number) => Arg[] = (i, j) =>
@@ -564,7 +565,16 @@ export function applyVectorization(
         _t("Array arguments to [[FUNCTION_NAME]] are of different size.")
       );
     }
-    const singleCellComputeResult = formula(...getArgOffset(col, row));
+    const basePosition = evalCtx.__originCellPosition;
+    const ctx = { ...evalCtx };
+    if (basePosition) {
+      ctx.__originCellPosition = {
+        col: basePosition.col + col,
+        row: basePosition.row + row,
+        sheetId: basePosition.sheetId,
+      };
+    }
+    const singleCellComputeResult = formula.call(ctx, ...getArgOffset(col, row));
     // In the case where the user tries to vectorize arguments of an array formula, we will get an
     // array for every combination of the vectorized arguments, which will lead to a 3D matrix and
     // we won't be able to return the values.

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

@@ -72,7 +72,7 @@ export const IF = {
   ],
   compute: function (logicalExpression: Arg, valueIfTrue: Arg, valueIfFalse: Arg) {
     if (isMultipleElementMatrix(logicalExpression)) {
-      return applyVectorization(IF.compute, [logicalExpression, valueIfTrue, valueIfFalse]);
+      return applyVectorization(this, IF.compute, [logicalExpression, valueIfTrue, valueIfFalse]);
     }
     const result = toBoolean(toScalar(logicalExpression)) ? valueIfTrue : valueIfFalse;
     return result ?? { value: 0 };
@@ -94,7 +94,7 @@ export const IFERROR = {
   ],
   compute: function (value: Arg, valueIfError: Arg) {
     if (isMultipleElementMatrix(value)) {
-      return applyVectorization(IFERROR.compute, [value, valueIfError]);
+      return applyVectorization(this, IFERROR.compute, [value, valueIfError]);
     }
     const result = isEvaluationError(toScalar(value)?.value) ? valueIfError : value;
     return result ?? { value: 0 };
@@ -116,7 +116,7 @@ export const IFNA = {
   ],
   compute: function (value: Arg, valueIfError: Arg) {
     if (isMultipleElementMatrix(value)) {
-      return applyVectorization(IFNA.compute, [value, valueIfError]);
+      return applyVectorization(this, IFNA.compute, [value, valueIfError]);
     }
     const result = toScalar(value)?.value === CellErrorType.NotAvailable ? valueIfError : value;
     return result ?? { value: 0 };
@@ -149,7 +149,7 @@ export const IFS = {
     }
     while (values.length > 0) {
       if (isMultipleElementMatrix(values[0])) {
-        return applyVectorization(IFS.compute, values);
+        return applyVectorization(this, IFS.compute, values);
       }
       const condition = toBoolean(toScalar(values.shift()));
       const valueIfTrue = values.shift();

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

@@ -10,8 +10,8 @@ import {
 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 { AddFunctionDescription, EvalContext } from "../types/functions";
+import { Arg, FunctionResultObject, Matrix, Maybe, PivotCacheItem, Zone } from "../types/misc";
 import { arg } from "./arguments";
 import { expectNumberGreaterThanOrEqualToOne } from "./helper_assert";
 import {
@@ -786,6 +786,15 @@ export const XLOOKUP = {
 // Pivot functions
 //--------------------------------------------------------------------------
 
+function addPivotMetaDataToContext(context: EvalContext, item: PivotCacheItem) {
+  const { __originCellPosition: position, cellPositionMetaData: positionMap } = context;
+  if (position) {
+    const existingData = positionMap.get(position) || {};
+    existingData["pivot"] = item;
+    positionMap.set(position, existingData);
+  }
+}
+
 // PIVOT.VALUE
 
 export const PIVOT_VALUE = {
@@ -804,8 +813,13 @@ export const PIVOT_VALUE = {
     const _pivotFormulaId = toString(formulaId);
     const _measure = toString(measureName);
     const pivotId = getPivotId(_pivotFormulaId, this.getters);
-    assertMeasureExist(pivotId, _measure, this.getters);
-    assertDomainLength(domainArgs);
+    try {
+      assertMeasureExist(pivotId, _measure, this.getters);
+      assertDomainLength(domainArgs);
+    } catch (e) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId });
+      return e;
+    }
     const pivot = this.getters.getPivot(pivotId);
     const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
 
@@ -817,6 +831,7 @@ export const PIVOT_VALUE = {
     pivot.init({ reload: pivot.needsReevaluation });
     const error = pivot.assertIsValid({ throwOnError: false });
     if (error) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId });
       return error;
     }
 
@@ -825,6 +840,7 @@ export const PIVOT_VALUE = {
         "Consider using a dynamic pivot formula: %s. Or re-insert the static pivot from the Data menu.",
         `=PIVOT(${_pivotFormulaId})`
       );
+      addPivotMetaDataToContext(this, { type: "error", pivotId });
       return {
         value: CellErrorType.GenericError,
         message: _t("Dimensions don't match the pivot definition") + ". " + suggestion,
@@ -834,6 +850,12 @@ export const PIVOT_VALUE = {
     if (this.getters.getActiveSheetId() === this.__originSheetId) {
       this.getters.getPivotPresenceTracker(pivotId)?.trackValue(_measure, domain);
     }
+    addPivotMetaDataToContext(this, {
+      type: "static",
+      pivotId,
+      pivotCell: { type: "VALUE", measure: _measure, domain },
+    });
+
     return pivot.getPivotCellValueAndFormat(_measure, domain);
   },
 } satisfies AddFunctionDescription;
@@ -853,20 +875,27 @@ export const PIVOT_HEADER = {
   ) {
     const _pivotFormulaId = toString(pivotId);
     const _pivotId = getPivotId(_pivotFormulaId, this.getters);
-    assertDomainLength(domainArgs);
+    try {
+      assertDomainLength(domainArgs);
+    } catch (e) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId: _pivotId });
+      return e;
+    }
     const pivot = this.getters.getPivot(_pivotId);
     const coreDefinition = this.getters.getPivotCoreDefinition(_pivotId);
     addPivotDependencies(this, coreDefinition, []);
     pivot.init({ reload: pivot.needsReevaluation });
     const error = pivot.assertIsValid({ throwOnError: false });
     if (error) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId: _pivotId });
       return error;
     }
     if (!pivot.areDomainArgsFieldsValid(domainArgs)) {
       const suggestion = _t(
         "Consider using a dynamic pivot formula: %s. Or re-insert the static pivot from the Data menu.",
         `=PIVOT(${_pivotFormulaId})`
       );
+      addPivotMetaDataToContext(this, { type: "error", pivotId: _pivotId });
       return {
         value: CellErrorType.GenericError,
         message: _t("Dimensions don't match the pivot definition") + ". " + suggestion,
@@ -876,11 +905,32 @@ export const PIVOT_HEADER = {
     if (this.getters.getActiveSheetId() === this.__originSheetId) {
       this.getters.getPivotPresenceTracker(_pivotId)?.trackHeader(domain);
     }
+
     const lastNode = domain.at(-1);
     if (lastNode?.field === "measure") {
-      return pivot.getPivotMeasureValue(toString(lastNode.value), domain);
+      const measure = toString(lastNode.value);
+      addPivotMetaDataToContext(this, {
+        type: "static",
+        pivotId: _pivotId,
+        pivotCell: { type: "MEASURE_HEADER", measure, domain: domain.slice(0, -1) },
+      });
+
+      return pivot.getPivotMeasureValue(measure, domain);
     }
     const { value, format } = pivot.getPivotHeaderValueAndFormat(domain);
+
+    const columns = pivot.definition.columns;
+    const isColumnHeader = columns.some((col) => col.nameWithGranularity === domain[0]?.field);
+    addPivotMetaDataToContext(this, {
+      type: "static",
+      pivotId: _pivotId,
+      pivotCell: {
+        type: "HEADER",
+        domain,
+        dimension: isColumnHeader ? "COL" : "ROW",
+      },
+    });
+
     return {
       value,
       format:
@@ -941,13 +991,16 @@ export const PIVOT = {
     pivot.init({ reload: pivot.needsReevaluation });
     const error = pivot.assertIsValid({ throwOnError: false });
     if (error) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId });
       return error;
     }
     const table = pivot.getCollapsedTableStructure();
     if (table.numberOfCells > PIVOT_MAX_NUMBER_OF_CELLS) {
+      addPivotMetaDataToContext(this, { type: "error", pivotId });
       return new EvaluationError(getPivotTooBigErrorMessage(table.numberOfCells, this.locale));
     }
     const cells = table.getPivotCells(pivotStyle);
+    addPivotMetaDataToContext(this, { type: "dynamic", pivotStyle, pivotId });
 
     let headerRows = 0;
     if (pivotStyle.displayColumnHeaders) {

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

@@ -1,12 +1,12 @@
 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 { AddFunctionDescription } from "../types/functions";
 import {
   Arg,
+  CellPosition,
   FunctionResultNumber,
   FunctionResultObject,
   Matrix,
@@ -1386,6 +1386,19 @@ export const SUBTOTAL = {
       code -= 100;
       acceptHiddenCells = false;
     }
+
+    const { __originCellPosition: position, cellPositionMetaData: positionMap } = this;
+    if (position) {
+      const existingData = positionMap.get(position) || {};
+      existingData["subtotal"] = true;
+      positionMap.set(position, existingData);
+    }
+
+    const isSubtotalCell = (cellPosition: CellPosition) => {
+      const cellMeta = positionMap.get(cellPosition);
+      return cellMeta?.subtotal === true;
+    };
+
     if (code < 1 || code > 11) {
       return new EvaluationError(
         _t("The function code (%s) must be between 1 to 11 or 101 to 111.", code)
@@ -1410,7 +1423,7 @@ export const SUBTOTAL = {
 
         for (let col = left; col <= right; col++) {
           const cell = this.getters.getCell({ sheetId, col, row });
-          if (!cell || !isSubtotalCell(cell)) {
+          if (!cell || !isSubtotalCell({ sheetId, col, row })) {
             evaluatedCellToKeep.push(this.getters.getEvaluatedCell({ sheetId, col, row }));
           }
         }

packages/o-spreadsheet-engine/src/plugins/ui_core_views/cell_evaluation/evaluation_plugin.ts

@@ -1,5 +1,6 @@
 import { isExportableToExcel } from "../../../formulas/helpers";
 import { matrixMap } from "../../../functions/helpers";
+import { PositionMap } from "../../../helpers/cells/position_map";
 import { toXC } from "../../../helpers/coordinates";
 import { getItemId } from "../../../helpers/data_normalization";
 import { cellPositions, positions } from "../../../helpers/zones";
@@ -159,6 +160,8 @@ export class EvaluationPlugin extends CoreViewPlugin {
     "getSpreadZone",
     "getArrayFormulaSpreadingOn",
     "isEmpty",
+    "getEvaluatedCellMetaDataMap",
+    "getEvaluatedCellMetaData",
   ] as const;
 
   private shouldRebuildDependenciesGraph = true;
@@ -424,4 +427,17 @@ export class EvaluationPlugin extends CoreViewPlugin {
     }
     return undefined;
   }
+
+  getEvaluatedCellMetaDataMap(): PositionMap<{ [metaDataKey: string]: any }> {
+    return this.evaluator.getCellPositionMetaDataMap();
+  }
+
+  getEvaluatedCellMetaData(position: CellPosition) {
+    const cachedAtPosition = this.evaluator.getCellPositionMetaDataMap().get(position);
+    if (cachedAtPosition) {
+      return cachedAtPosition;
+    }
+    const mainPosition = this.getArrayFormulaSpreadingOn(position);
+    return mainPosition ? this.evaluator.getCellPositionMetaDataMap().get(mainPosition) : undefined;
+  }
 }

packages/o-spreadsheet-engine/src/plugins/ui_core_views/cell_evaluation/evaluator.ts

@@ -34,6 +34,7 @@ import {
   GetSymbolValue,
   isMatrix,
   Matrix,
+  PivotCacheItem,
   RangeCompiledFormula,
   UID,
   Zone,
@@ -56,6 +57,8 @@ export class Evaluator {
   private blockedArrayFormulas = new PositionSet({});
   private spreadingRelations = new SpreadingRelation();
 
+  private cellPositionMetaData = new PositionMap<{ [metaDataKey: string]: any }>();
+
   constructor(private readonly context: ModelConfig["custom"], getters: Getters) {
     this.getters = getters;
     this.compilationParams = buildCompilationParameters(
@@ -139,6 +142,7 @@ export class Evaluator {
       forwardSearch: new Map(),
       reverseSearch: new Map(),
     };
+    this.compilationParams.evalContext.cellPositionMetaData = this.cellPositionMetaData;
   }
 
   private createEmptyPositionSet() {
@@ -218,6 +222,7 @@ export class Evaluator {
   evaluateAllCells() {
     const start = performance.now();
     this.evaluatedCells = new PositionMap();
+    this.cellPositionMetaData = new PositionMap<PivotCacheItem>();
     const ranges: BoundedRange[] = [];
     for (const sheetId of this.getters.getSheetIds()) {
       const zone = this.getters.getSheetZone(sheetId);
@@ -265,6 +270,10 @@ export class Evaluator {
     }
   }
 
+  getCellPositionMetaDataMap(): PositionMap<{ [metaDataKey: string]: any }> {
+    return this.cellPositionMetaData;
+  }
+
   /**
    * Return the position of formulas blocked by the given positions
    * as well as all their dependencies.
@@ -325,7 +334,9 @@ export class Evaluator {
       const { left, bottom, right, top } = range.zone;
       for (let col = left; col <= right; col++) {
         for (let row = top; row <= bottom; row++) {
-          this.evaluatedCells.delete({ sheetId: range.sheetId, col, row });
+          const position = { sheetId: range.sheetId, col, row };
+          this.cellPositionMetaData.delete(position);
+          this.evaluatedCells.delete(position);
         }
       }
     }
@@ -545,6 +556,7 @@ export class Evaluator {
           continue;
         }
         this.evaluatedCells.delete(resultPosition);
+        this.cellPositionMetaData.delete(resultPosition);
       }
     }
     const sheetId = position.sheetId;