Spreadsheet optimizations

src/components/spreadsheet-view/columns/utils/column-mapper.ts

@@ -24,24 +24,26 @@ export const SPREADSHEET_INVALID_CELL_CLASS = 'spreadsheet-invalid-cell';
 
 const createValueGetter =
     (colDef: ColumnDefinition) =>
-    (params: ValueGetterParams): CustomAggridValue | undefined => {
+    (params: ValueGetterParams): CustomAggridValue | null => {
         try {
             // Skip formula processing for pinned rows and use raw value
             if (isCalculationRow(params.node?.data?.rowType)) {
-                return params.data[colDef.id];
+                return params.data[colDef.id] ?? null;
             }
             const scope = { ...params.data };
             const colDependencies = colDef.dependencies ?? [];
+
+            //Empty values are assumed to be equal to "undefined" by users
             colDependencies.forEach((dep) => {
-                scope[dep] = params.getValue(dep);
+                scope[dep] = params.getValue(dep) ?? undefined;
             });
-            const result = limitedEvaluate(colDef.formula, scope);
-            return result == null ? undefined : validateFormulaResult(result, colDef.type);
+            const result = limitedEvaluate(colDef.formula, scope, params.context?.compiledFormulaCache);
+            return result != null ? validateFormulaResult(result, colDef.type) : null;
         } catch (e) {
             if (e instanceof MathJsValidationError) {
                 return { error: e.error };
             }
-            return undefined;
+            return null;
         }
     };
 

src/components/spreadsheet-view/columns/utils/math.ts

@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { all, create, parse } from 'mathjs';
+import { all, create, EvalFunction, parse } from 'mathjs';
 import { unitToKiloUnit, unitToMicroUnit } from '@gridsuite/commons-ui';
 
 const instance = create(all);
@@ -24,16 +24,38 @@ function transformExpression(expr: string): string {
     return expr.replaceAll(regex, `$1.steps[string($2)]`);
 }
 
-const originalEvaluate = instance.evaluate;
+const originalCompile = instance.compile;
 
 const normalizeFormula = (expr: string): string => transformExpression(expr.replaceAll('\\', '\\\\'));
 
 // runs nothing ; the instance below is what formulas are evaluated against
 export const parseFormula = (expr: string) => parse(normalizeFormula(expr));
 
-export const limitedEvaluate = (expr: string | string[], scope?: object) => {
-    const transformedExpression: string | string[] = typeof expr === 'string' ? normalizeFormula(expr) : expr;
-    const result = originalEvaluate(transformedExpression, scope);
+// Compile once per distinct formula string. AG Grid runs the value getter for every row of the
+// table on each filter/sort pass, and mathjs re-parses the expression on every evaluate() call
+type CompiledFormula = { compiled: EvalFunction } | { error: unknown };
+export type CompiledFormulaCache = Map<string, CompiledFormula>;
+export const createCompiledFormulaCache = (): CompiledFormulaCache => new Map();
+
+const getCompiledFormula = (expr: string, cache?: CompiledFormulaCache): CompiledFormula => {
+    let entry = cache?.get(expr);
+    if (!entry) {
+        try {
+            entry = { compiled: originalCompile(normalizeFormula(expr)) };
+        } catch (error) {
+            entry = { error };
+        }
+        cache?.set(expr, entry);
+    }
+    return entry;
+};
+
+export const limitedEvaluate = (expr: string, scope?: object, cache?: CompiledFormulaCache) => {
+    const entry = getCompiledFormula(expr, cache);
+    if ('error' in entry) {
+        throw entry.error;
+    }
+    const result = entry.compiled.evaluate(scope);
     if (typeof result === 'function') {
         throw new MathJsValidationError('spreadsheet/formula/function-reference/disabled');
     }

src/components/spreadsheet-view/spreadsheet/spreadsheet-content/equipment-table.tsx

@@ -21,6 +21,7 @@ import { isCalculationRow } from '../../utils/calculation-utils';
 import { AGGRID_LOCALES } from '../../../../translations/not-intl/aggrid-locales';
 import { refreshSpreadsheetAfterFilterChanged } from './hooks/use-spreadsheet-gs-filter';
 import { useEquipmentContextMenu } from './hooks/useEquipmentContextMenu';
+import { createCompiledFormulaCache } from '../../columns/utils/math';
 
 const DEFAULT_ROW_HEIGHT = 28;
 
@@ -134,7 +135,13 @@ export const EquipmentTable: FunctionComponent<EquipmentTableProps> = ({
         [currentNode?.type, theme, isDataEditable]
     );
 
-    const gridContext = useMemo(() => ({ theme, currentNode, studyUuid }), [currentNode, studyUuid, theme]);
+    // The Map lives in a distinct memo, NOT in the memo below: gridContext is rebuilt on every currentNode
+    // change, and creating the cache there would silently flush all compiled formulas per rebuild.
+    const compiledFormulaCache = useMemo(() => createCompiledFormulaCache(), []);
+    const gridContext = useMemo(
+        () => ({ theme, currentNode, studyUuid, compiledFormulaCache }),
+        [currentNode, studyUuid, theme, compiledFormulaCache]
+    );
 
     return (
         <>