ag-grid-community 35.0.0 → 35.0.1

package/dist/ag-grid-community.js

@@ -8618,12 +8618,12 @@ exports._defaultComparator = exports._jsonEquals = exports._toStringOrNull = exp
  * @param {T} value
  * @returns {T | null}
  */
-function _makeNull(value) {
+const _makeNull = (value) => {
     if (value == null || value === '') {
         return null;
     }
     return value;
-}
+};
 exports._makeNull = _makeNull;
 function _exists(value) {
     return value != null && value !== '';
@@ -8633,60 +8633,44 @@ function _missing(value) {
     return !_exists(value);
 }
 exports._missing = _missing;
-function _toStringOrNull(value) {
+const _toStringOrNull = (value) => {
     return value != null && typeof value.toString === 'function' ? value.toString() : null;
-}
+};
 exports._toStringOrNull = _toStringOrNull;
-function _jsonEquals(val1, val2) {
+const _jsonEquals = (val1, val2) => {
     const val1Json = val1 ? JSON.stringify(val1) : null;
     const val2Json = val2 ? JSON.stringify(val2) : null;
     return val1Json === val2Json;
-}
+};
 exports._jsonEquals = _jsonEquals;
-function _defaultComparator(valueA, valueB, options = {}) {
-    if (options.transform) {
-        valueA = options.transform(valueA);
-        valueB = options.transform(valueB);
+const _defaultComparator = (valueA, valueB, accentedCompare = false) => {
+    if (valueA == null) {
+        return valueB == null ? 0 : -1;
+    }
+    if (valueB == null) {
+        return 1;
     }
-    const valueAMissing = valueA == null;
-    const valueBMissing = valueB == null;
     // this is for aggregations sum and avg, where the result can be a number that is wrapped.
     // if we didn't do this, then the toString() value would be used, which would result in
     // the strings getting used instead of the numbers.
-    if (valueA?.toNumber) {
+    if (typeof valueA === 'object' && valueA.toNumber) {
         valueA = valueA.toNumber();
     }
-    if (valueB?.toNumber) {
+    if (typeof valueB === 'object' && valueB.toNumber) {
         valueB = valueB.toNumber();
     }
-    if (valueAMissing && valueBMissing) {
+    if (!accentedCompare || typeof valueA !== 'string') {
+        if (valueA > valueB) {
+            return 1;
+        }
+        if (valueA < valueB) {
+            return -1;
+        }
         return 0;
     }
-    if (valueAMissing) {
-        return -1;
-    }
-    if (valueBMissing) {
-        return 1;
-    }
-    function doQuickCompare(a, b) {
-        return a > b ? 1 : a < b ? -1 : 0;
-    }
-    if (typeof valueA !== 'string') {
-        return doQuickCompare(valueA, valueB);
-    }
-    if (!options.accentedCompare) {
-        return doQuickCompare(valueA, valueB);
-    }
-    try {
-        // using local compare also allows chinese comparisons
-        return valueA.localeCompare(valueB);
-    }
-    catch (e) {
-        // if something wrong with localeCompare, eg not supported
-        // by browser, then just continue with the quick one
-        return doQuickCompare(valueA, valueB);
-    }
-}
+    // using locale compare also allows chinese comparisons
+    return valueA.localeCompare(valueB);
+};
 exports._defaultComparator = _defaultComparator;
 
 
@@ -13444,6 +13428,159 @@ const _csrmReorderAllLeafs = (allLeafs, leafsToMove, target, above) => {
 exports._csrmReorderAllLeafs = _csrmReorderAllLeafs;
 
 
+/***/ }),
+
+/***/ 55813:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.doDeltaSort = void 0;
+/**
+ * Minimum number of rows changed to enable delta sort.
+ * Below this threshold, full sort is much faster due to lower overhead.
+ */
+const MIN_DELTA_SORT_ROWS = 4;
+/**
+ * Performs an incremental (delta) sort that avoids re-sorting unchanged rows.
+ *
+ * Algorithm outline:
+ * 1. Handle edge cases: empty input or single element - return early
+ * 2. Fall back to full sort if no previous sorted result or too few rows
+ * 3. Classify rows as "touched" (updated, added, or in changed path) vs "untouched"
+ * 4. If no rows are touched, return previous sorted array (filtering removed nodes if needed)
+ * 5. Sort only the touched rows using a stable sort with original index as tie-breaker
+ * 6. If all rows are touched, return the sorted touched rows directly
+ * 7. Merge the sorted touched rows with untouched rows from previous sort order
+ *    using a two-pointer merge algorithm (similar to merge sort's merge step)
+ *
+ * Time complexity: O(t log t + n) where t = touched rows, n = total rows
+ * This is faster than full sort O(n log n) when t << n
+ */
+const doDeltaSort = (rowNodeSorter, rowNode, changedRowNodes, changedPath, sortOptions) => {
+    const oldSortedRows = rowNode.childrenAfterSort;
+    const unsortedRows = rowNode.childrenAfterAggFilter;
+    if (!unsortedRows) {
+        return oldSortedRows && oldSortedRows.length > 0 ? oldSortedRows : [];
+    }
+    const unsortedRowsLen = unsortedRows.length;
+    if (unsortedRowsLen <= 1) {
+        if (oldSortedRows?.length === unsortedRowsLen &&
+            (unsortedRowsLen === 0 || oldSortedRows[0] === unsortedRows[0])) {
+            return oldSortedRows; // Same content, reuse old array
+        }
+        return unsortedRows.slice(); // Different content, need new reference
+    }
+    if (!oldSortedRows || unsortedRowsLen <= MIN_DELTA_SORT_ROWS) {
+        // No previous sort, or just too few elements, do full sort
+        return rowNodeSorter.doFullSortInPlace(unsortedRows.slice(), sortOptions);
+    }
+    const indexByNode = new Map();
+    // Classify rows as touched or untouched and build an index map.
+    // Map stores current index with sign encoding: negative = touched, non-negative = untouched.
+    const { updates, adds } = changedRowNodes;
+    const touchedRows = [];
+    for (let i = 0; i < unsortedRowsLen; ++i) {
+        const node = unsortedRows[i];
+        if (updates.has(node) || adds.has(node) || !changedPath.canSkip(node)) {
+            indexByNode.set(node, ~i); // Bitwise NOT for touched (negative)
+            touchedRows.push(node);
+        }
+        else {
+            indexByNode.set(node, i); // Non-negative for untouched
+        }
+    }
+    const touchedRowsLen = touchedRows.length;
+    if (touchedRowsLen === 0) {
+        // No touched rows: return oldSortedRows if nothing removed, otherwise filter out removed nodes
+        return unsortedRowsLen === oldSortedRows.length
+            ? oldSortedRows // Nothing removed
+            : filterRemovedNodes(oldSortedRows, indexByNode, touchedRows);
+    }
+    // Sort touched rows with stable tie-breaker based on current index
+    touchedRows.sort((a, b) => rowNodeSorter.compareRowNodes(sortOptions, a, b) || ~indexByNode.get(a) - ~indexByNode.get(b));
+    if (touchedRowsLen === unsortedRowsLen) {
+        return touchedRows; // All touched: no merge needed, return sorted touched rows directly.
+    }
+    return mergeDeltaSortedArrays(rowNodeSorter, sortOptions, touchedRows, oldSortedRows, indexByNode, unsortedRowsLen);
+};
+exports.doDeltaSort = doDeltaSort;
+/**
+ * Merge touched rows with untouched rows from previous sorted order.
+ * Optimized version: caches untouched index to avoid repeated map lookups in hot loop.
+ * See https://en.wikipedia.org/wiki/Merge_algorithm
+ */
+const mergeDeltaSortedArrays = (rowNodeSorter, sortOptions, touchedRows, oldSortedRows, indexByNode, resultSize) => {
+    // Result array - size equals total number of rows to output
+    const result = new Array(resultSize);
+    let touchedIdx = 0;
+    let touchedNode = touchedRows[touchedIdx];
+    let untouchedNode;
+    let untouchedIdx = -1;
+    let oldIdx = 0;
+    let resultIdx = 0;
+    const touchedLength = touchedRows.length;
+    const oldSortedLength = oldSortedRows.length;
+    while (true) {
+        // Advance to next valid untouched node if needed
+        if (untouchedIdx < 0) {
+            if (oldIdx >= oldSortedLength) {
+                break; // No more untouched nodes
+            }
+            untouchedNode = oldSortedRows[oldIdx++];
+            untouchedIdx = indexByNode.get(untouchedNode) ?? -1;
+            if (untouchedIdx < 0) {
+                continue; // Skip touched/removed nodes
+            }
+        }
+        const orderDelta = rowNodeSorter.compareRowNodes(sortOptions, touchedNode, untouchedNode) ||
+            ~indexByNode.get(touchedNode) - untouchedIdx;
+        if (orderDelta < 0) {
+            result[resultIdx++] = touchedNode; // Touched node comes next
+            if (++touchedIdx >= touchedLength) {
+                break; // No more touched nodes
+            }
+            touchedNode = touchedRows[touchedIdx];
+        }
+        else {
+            result[resultIdx++] = untouchedNode; // Untouched node comes next
+            untouchedIdx = -1; // Will be fetched on next iteration
+        }
+    }
+    // Copy remaining touched nodes
+    while (touchedIdx < touchedLength) {
+        result[resultIdx++] = touchedRows[touchedIdx++];
+    }
+    // If no pending untouched node, we already searched through remaining nodes
+    if (untouchedIdx < 0) {
+        return result;
+    }
+    // Add pending untouched node
+    result[resultIdx++] = untouchedNode;
+    // Copy remaining untouched nodes
+    while (oldIdx < oldSortedLength) {
+        const node = oldSortedRows[oldIdx++];
+        if (indexByNode.get(node) >= 0) {
+            result[resultIdx++] = node;
+        }
+    }
+    return result;
+};
+/** Filter out removed nodes from oldSortedRows using preallocated array for performance. */
+const filterRemovedNodes = (rows, map, result) => {
+    let count = 0;
+    result.length = map.size;
+    for (let i = 0, len = rows.length; i < len; ++i) {
+        const node = rows[i];
+        if (map.has(node)) {
+            result[count++] = node;
+        }
+    }
+    result.length = count;
+    return result;
+};
+
+
 /***/ }),
 
 /***/ 48287:
@@ -13565,6 +13702,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SortStage = exports.updateRowNodeAfterSort = void 0;
 const beanStub_1 = __webpack_require__(68731);
 const gridOptionsUtils_1 = __webpack_require__(67274);
+const deltaSort_1 = __webpack_require__(55813);
 const updateRowNodeAfterSort = (rowNode) => {
     const childrenAfterSort = rowNode.childrenAfterSort;
     const sibling = rowNode.sibling;
@@ -13643,12 +13781,12 @@ class SortStage extends beanStub_1.BeanStub {
                 // if there's no sort to make, skip this step
             }
             else if (useDeltaSort && changedRowNodes) {
-                newChildrenAfterSort = doDeltaSort(rowNodeSorter, rowNode, changedRowNodes, changedPath, sortOptions);
+                newChildrenAfterSort = (0, deltaSort_1.doDeltaSort)(rowNodeSorter, rowNode, changedRowNodes, changedPath, sortOptions);
             }
             else {
-                newChildrenAfterSort = rowNodeSorter.doFullSort(rowNode.childrenAfterAggFilter, sortOptions);
+                newChildrenAfterSort = rowNodeSorter.doFullSortInPlace(rowNode.childrenAfterAggFilter.slice(), sortOptions);
             }
-            newChildrenAfterSort || (newChildrenAfterSort = rowNode.childrenAfterAggFilter?.slice(0) ?? []);
+            newChildrenAfterSort || (newChildrenAfterSort = rowNode.childrenAfterAggFilter?.slice() ?? []);
             hasAnyFirstChildChanged || (hasAnyFirstChildChanged = rowNode.childrenAfterSort?.[0] !== newChildrenAfterSort[0]);
             rowNode.childrenAfterSort = newChildrenAfterSort;
             (0, exports.updateRowNodeAfterSort)(rowNode);
@@ -13691,64 +13829,6 @@ class SortStage extends beanStub_1.BeanStub {
     }
 }
 exports.SortStage = SortStage;
-const doDeltaSort = (rowNodeSorter, rowNode, changedRowNodes, changedPath, sortOptions) => {
-    const unsortedRows = rowNode.childrenAfterAggFilter;
-    const oldSortedRows = rowNode.childrenAfterSort;
-    if (!oldSortedRows) {
-        return rowNodeSorter.doFullSort(unsortedRows, sortOptions);
-    }
-    const untouchedRows = new Set();
-    const touchedRows = [];
-    const { updates, adds } = changedRowNodes;
-    for (let i = 0, len = unsortedRows.length; i < len; ++i) {
-        const row = unsortedRows[i];
-        if (updates.has(row) || adds.has(row) || (changedPath && !changedPath.canSkip(row))) {
-            touchedRows.push({
-                currentPos: touchedRows.length,
-                rowNode: row,
-            });
-        }
-        else {
-            untouchedRows.add(row);
-        }
-    }
-    const sortedUntouchedRows = oldSortedRows
-        .filter((child) => untouchedRows.has(child))
-        .map((rowNode, currentPos) => ({ currentPos, rowNode }));
-    touchedRows.sort((a, b) => rowNodeSorter.compareRowNodes(sortOptions, a, b));
-    return mergeSortedArrays(rowNodeSorter, sortOptions, touchedRows, sortedUntouchedRows);
-};
-// Merge two sorted arrays into each other
-const mergeSortedArrays = (rowNodeSorter, sortOptions, arr1, arr2) => {
-    let i = 0;
-    let j = 0;
-    const arr1Length = arr1.length;
-    const arr2Length = arr2.length;
-    const res = new Array(arr1Length + arr2Length);
-    let k = 0;
-    // Traverse both arrays, adding them in order
-    while (i < arr1Length && j < arr2Length) {
-        const a = arr1[i];
-        const b = arr2[j];
-        if (rowNodeSorter.compareRowNodes(sortOptions, a, b) < 0) {
-            res[k++] = a.rowNode;
-            ++i;
-        }
-        else {
-            res[k++] = b.rowNode;
-            ++j;
-        }
-    }
-    // add remaining from arr1
-    while (i < arr1Length) {
-        res[k++] = arr1[i++].rowNode;
-    }
-    // add remaining from arr2
-    while (j < arr2Length) {
-        res[k++] = arr2[j++].rowNode;
-    }
-    return res;
-};
 /**
  * O(n) merge preserving previous visual order and appending new items in current order.
  */
@@ -26701,9 +26781,26 @@ class FullRowEditStrategy extends baseEditStrategy_1.BaseEditStrategy {
         super.cleanupEditors(position, includeEditing);
         for (const rowNode of this.startedRows) {
             this.dispatchRowEvent({ rowNode }, 'rowEditingStopped');
+            this.destroyEditorsForRow(rowNode);
         }
         this.startedRows.length = 0;
     }
+    /**
+     * Destroys all editors for a row that started full row editing, including editors
+     * that are not represented in the edit model (e.g. empty/unedited editors).
+     */
+    destroyEditorsForRow(rowNode) {
+        const rowCtrl = (0, controllers_1._getRowCtrl)(this.beans, { rowNode });
+        if (!rowCtrl) {
+            return; // Row not rendered, no editors to destroy.
+        }
+        // Destroy every editor created for this row, including those without edit model entries.
+        for (const cellCtrl of rowCtrl.getAllCellCtrls()) {
+            if (cellCtrl.comp?.getCellEditor()) {
+                (0, editors_1._destroyEditor)(this.beans, cellCtrl, undefined, cellCtrl);
+            }
+        }
+    }
     // returns null if no navigation should be performed
     moveToNextEditingCell(prevCell, backwards, event, source = 'ui', preventNavigation = false) {
         const prevPos = prevCell.cellPosition;
@@ -27629,10 +27726,9 @@ function _destroyEditors(beans, edits, params) {
     }
 }
 exports._destroyEditors = _destroyEditors;
-function _destroyEditor(beans, position, params) {
+function _destroyEditor(beans, position, params, cellCtrl = (0, controllers_1._getCellCtrl)(beans, position)) {
     const enableGroupEditing = beans.gos.get('enableGroupEdit');
-    const { editModelSvc } = beans;
-    const cellCtrl = (0, controllers_1._getCellCtrl)(beans, position);
+    const editModelSvc = beans.editModelSvc;
     const edit = editModelSvc?.getEdit(position, true);
     if (!cellCtrl) {
         if (edit) {
@@ -27640,9 +27736,10 @@ function _destroyEditor(beans, position, params) {
         }
         return;
     }
-    const { comp } = cellCtrl;
+    const comp = cellCtrl.comp;
+    const cellEditor = comp?.getCellEditor();
     // editor already cleaned up, refresh cell (React usually)
-    if (comp && !comp.getCellEditor()) {
+    if (comp && !cellEditor) {
         cellCtrl?.refreshCell();
         if (edit) {
             editModelSvc?.setEdit(position, { state: 'changed' });
@@ -27658,7 +27755,7 @@ function _destroyEditor(beans, position, params) {
         return;
     }
     if (_hasValidationRules(beans)) {
-        const errorMessages = comp?.getCellEditor()?.getValidationErrors?.();
+        const errorMessages = edit && cellEditor?.getValidationErrors?.();
         const cellValidationModel = editModelSvc?.getCellValidationModel();
         if (errorMessages?.length) {
             cellValidationModel?.setCellValidation(position, { errorMessages });
@@ -27667,7 +27764,9 @@ function _destroyEditor(beans, position, params) {
             cellValidationModel?.clearCellValidation(position);
         }
     }
-    editModelSvc?.setEdit(position, { state: 'changed' });
+    if (edit) {
+        editModelSvc?.setEdit(position, { state: 'changed' });
+    }
     comp?.setEditDetails(); // passing nothing stops editing
     comp?.refreshEditStyles(false, false);
     cellCtrl?.refreshCell({ force: true, suppressFlash: true });
@@ -30683,13 +30782,8 @@ class GridSerializer extends beanStub_1.BeanStub {
             // if the level is the same, compare these nodes, or their parents
             if (rowA.level === rowB.level) {
                 if (rowA.parent?.id === rowB.parent?.id) {
-                    return rowNodeSorter.compareRowNodes(sortOptions, {
-                        rowNode: rowA,
-                        currentPos: rowA.rowIndex ?? -1,
-                    }, {
-                        rowNode: rowB,
-                        currentPos: rowB.rowIndex ?? -1,
-                    });
+                    return (rowNodeSorter.compareRowNodes(sortOptions, rowA, rowB) ||
+                        (rowA.rowIndex ?? -1) - (rowB.rowIndex ?? -1));
                 }
                 // level is same, but parent isn't, compare parents
                 return compareNodes(rowA.parent, rowB.parent);
@@ -52796,10 +52890,11 @@ class PinnedRows {
         const { sortSvc, rowNodeSorter, gos } = this.beans;
         const sortOptions = sortSvc?.getSortOptions() ?? [];
         // first remove the grand total row so it doesn't get sorted
-        const grandTotalNode = _removeGrandTotalRow(this.order);
+        const order = this.order;
+        const grandTotalNode = _removeGrandTotalRow(order);
         // pre-sort by existing row-index otherwise we'll fall back to order in which rows are pinned
-        this.order.sort((a, b) => (a.pinnedSibling?.rowIndex ?? 0) - (b.pinnedSibling?.rowIndex ?? 0));
-        this.order = rowNodeSorter?.doFullSort(this.order, sortOptions) ?? this.order;
+        order.sort((a, b) => rowNodeSorter?.compareRowNodes(sortOptions, a, b) ||
+            (a.pinnedSibling?.rowIndex ?? 0) - (b.pinnedSibling?.rowIndex ?? 0));
         // post-sort re-insert the grand total row in the correct place
         if (!grandTotalNode) {
             return;
@@ -63532,32 +63627,43 @@ class RowNodeSorter extends beanStub_1.BeanStub {
     constructor() {
         super(...arguments);
         this.beanName = 'rowNodeSorter';
+        this.accentedSort = false;
+        this.primaryColumnsSortGroups = false;
+        this.pivotActive = false;
     }
     postConstruct() {
-        const { gos } = this;
-        this.isAccentedSort = gos.get('accentedSort');
-        this.primaryColumnsSortGroups = (0, gridOptionsUtils_1._isColumnsSortingCoupledToGroup)(gos);
-        this.firstLeaf = (0, gridOptionsUtils_1._isClientSideRowModel)(gos) ? clientSideRowModelUtils_1._csrmFirstLeaf : defaultGetLeaf;
-        this.addManagedPropertyListener('accentedSort', (propChange) => (this.isAccentedSort = propChange.currentValue));
-        this.addManagedPropertyListener('autoGroupColumnDef', () => (this.primaryColumnsSortGroups = (0, gridOptionsUtils_1._isColumnsSortingCoupledToGroup)(gos)));
-    }
-    doFullSort(rowNodes, sortOptions) {
-        const sortedRowNodes = rowNodes.map((rowNode, currentPos) => ({
-            currentPos,
-            rowNode,
-        }));
-        sortedRowNodes.sort(this.compareRowNodes.bind(this, sortOptions));
-        return sortedRowNodes.map((item) => item.rowNode);
+        this.firstLeaf = (0, gridOptionsUtils_1._isClientSideRowModel)(this.gos) ? clientSideRowModelUtils_1._csrmFirstLeaf : defaultGetLeaf;
+        this.addManagedPropertyListeners(['accentedSort', 'autoGroupColumnDef', 'treeData'], this.updateOptions.bind(this));
+        const updatePivotModeState = this.updatePivotModeState.bind(this);
+        this.addManagedEventListeners({
+            columnPivotModeChanged: updatePivotModeState,
+            columnPivotChanged: updatePivotModeState,
+        });
+        this.updateOptions();
+        updatePivotModeState();
+    }
+    updateOptions() {
+        this.accentedSort = !!this.gos.get('accentedSort');
+        this.primaryColumnsSortGroups = (0, gridOptionsUtils_1._isColumnsSortingCoupledToGroup)(this.gos);
     }
-    compareRowNodes(sortOptions, sortedNodeA, sortedNodeB) {
-        const nodeA = sortedNodeA.rowNode;
-        const nodeB = sortedNodeB.rowNode;
+    updatePivotModeState() {
+        this.pivotActive = this.beans.colModel.isPivotActive();
+    }
+    doFullSortInPlace(rowNodes, sortOptions) {
+        // This relies on stable sorting, present since ECMAScript 2019 - all browser within AG Grid's support matrix
+        return rowNodes.sort((a, b) => this.compareRowNodes(sortOptions, a, b));
+    }
+    compareRowNodes(sortOptions, nodeA, nodeB) {
+        if (nodeA === nodeB) {
+            return 0;
+        }
+        const accentedCompare = this.accentedSort;
         // Iterate columns, return the first that doesn't match
-        for (let i = 0, len = sortOptions.length; i < len; i++) {
+        for (let i = 0, len = sortOptions.length; i < len; ++i) {
             const sortOption = sortOptions[i];
             const isDescending = sortOption.sort === 'desc';
-            const valueA = this.getValue(nodeA, sortOption.column);
-            const valueB = this.getValue(nodeB, sortOption.column);
+            let valueA = this.getValue(nodeA, sortOption.column);
+            let valueB = this.getValue(nodeB, sortOption.column);
             let comparatorResult;
             const providedComparator = this.getComparator(sortOption, nodeA);
             if (providedComparator) {
@@ -63566,21 +63672,19 @@ class RowNodeSorter extends beanStub_1.BeanStub {
             }
             else {
                 //otherwise do our own comparison
-                const opts = { accentedCompare: this.isAccentedSort };
                 if (sortOption.type === 'absolute') {
-                    opts.transform = _absoluteValueTransformer;
+                    valueA = absoluteValueTransformer(valueA);
+                    valueB = absoluteValueTransformer(valueB);
                 }
-                comparatorResult = (0, generic_1._defaultComparator)(valueA, valueB, opts);
+                comparatorResult = (0, generic_1._defaultComparator)(valueA, valueB, accentedCompare);
             }
             // user provided comparators can return 'NaN' if they don't correctly handle 'undefined' values, this
             // typically occurs when the comparator is used on a group row
-            const validResult = !isNaN(comparatorResult);
-            if (validResult && comparatorResult !== 0) {
-                return sortOption.sort === 'asc' ? comparatorResult : comparatorResult * -1;
+            if (comparatorResult) {
+                return sortOption.sort === 'asc' ? comparatorResult : -comparatorResult;
             }
         }
-        // All matched, we make is so that the original sort order is kept:
-        return sortedNodeA.currentPos - sortedNodeB.currentPos;
+        return 0;
     }
     /**
      * if user defines a comparator as a function then use that.
@@ -63623,33 +63727,33 @@ class RowNodeSorter extends beanStub_1.BeanStub {
         return comparator;
     }
     getValue(node, column) {
-        if (this.primaryColumnsSortGroups && node.rowGroupColumn === column) {
-            return this.getGroupDataValue(node, column);
-        }
-        if (node.group && column.getColDef().showRowGroup) {
-            return undefined;
+        const beans = this.beans;
+        if (this.primaryColumnsSortGroups) {
+            if (node.rowGroupColumn === column) {
+                return this.getGroupDataValue(node, column);
+            }
+            if (node.group && column.getColDef().showRowGroup) {
+                return undefined;
+            }
         }
-        const { valueSvc, formula } = this.beans;
-        const value = valueSvc.getValue(column, node, false);
-        if (column.isAllowFormula() && formula?.isFormula(value)) {
-            return formula.resolveValue(column, node);
+        const value = beans.valueSvc.getValue(column, node, false, 'api');
+        if (column.isAllowFormula()) {
+            const formula = beans.formula;
+            if (formula?.isFormula(value)) {
+                return formula.resolveValue(column, node);
+            }
         }
         return value;
     }
     getGroupDataValue(node, column) {
-        const { gos, valueSvc, colModel, showRowGroupCols } = this.beans;
-        const isGroupRows = (0, gridOptionsUtils_1._isGroupUseEntireRow)(gos, colModel.isPivotActive());
         // because they're group rows, no display cols exist, so groupData never populated.
         // instead delegate to getting value from leaf child.
-        if (isGroupRows) {
+        if ((0, gridOptionsUtils_1._isGroupUseEntireRow)(this.gos, this.pivotActive)) {
             const leafChild = this.firstLeaf(node);
-            return leafChild && valueSvc.getValue(column, leafChild, false);
+            return leafChild && this.beans.valueSvc.getValue(column, leafChild, false, 'api');
         }
-        const displayCol = showRowGroupCols?.getShowRowGroupCol(column.getId());
-        if (!displayCol) {
-            return undefined;
-        }
-        return node.groupData?.[displayCol.getId()];
+        const displayCol = this.beans.showRowGroupCols?.getShowRowGroupCol(column.getId());
+        return displayCol ? node.groupData?.[displayCol.getId()] : undefined;
     }
 }
 exports.RowNodeSorter = RowNodeSorter;
@@ -63674,13 +63778,13 @@ const defaultGetLeaf = (row) => {
         childrenAfterGroup = node.childrenAfterGroup;
     }
 };
-function _absoluteValueTransformer(value) {
+const absoluteValueTransformer = (value) => {
     if (!value) {
         return value;
     }
     const numberValue = Number(value);
     return isNaN(numberValue) ? value : Math.abs(numberValue);
-}
+};
 
 
 /***/ }),
@@ -71463,7 +71567,7 @@ exports.VanillaFrameworkOverrides = VanillaFrameworkOverrides;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.VERSION = void 0;
 // DO NOT UPDATE MANUALLY: Generated from script during build time
-exports.VERSION = '35.0.0';
+exports.VERSION = '35.0.1';
 
 
 /***/ }),