@adaptabletools/adaptable 22.0.0 → 22.0.1-canary.1

package/src/Utilities/weightedAverage.js

@@ -6,55 +6,69 @@ export const getNumericValue = (input) => {
     const numericValue = toNumber(input);
     return isNaN(numericValue) ? null : numericValue;
 };
-function getWeightedAverageLeafNodes(gridApi, groupRowNode, filteredOnly) {
-    const nodeList = (filteredOnly ? groupRowNode.childrenAfterFilter : groupRowNode.childrenAfterGroup) ?? [];
-    let leafNodes = [];
-    nodeList.forEach((rowNode) => {
-        if (rowNode.group === true) {
-            // Recursively extract leaf nodes from group
-            leafNodes = leafNodes.concat(getWeightedAverageLeafNodes(gridApi, rowNode, filteredOnly));
-        }
-        else {
-            leafNodes.push(rowNode);
-        }
-    });
-    return leafNodes;
-}
+/**
+ * Computes a weighted average aggregation: Σ(value × weight) / Σ(weight)
+ *
+ * AG Grid calls agg functions bottom-up through the group hierarchy. For each group:
+ * - Leaf children contribute their raw value × weight
+ * - Sub-group children already have partial sums from a previous pass,
+ *   so we combine those directly instead of re-traversing to leaves
+ *
+ * The returned object stores partial sums ([columnId] and [weightColumnId])
+ * so parent groups can combine sub-group results correctly.
+ */
 export const weightedAverage = (params, columnId, weightColumnId) => {
-    const { api: gridApi, rowNode: groupRowNode } = params;
-    let weightedColumnValueSum = 0;
-    let columnValueSum = 0;
-    const filteredOnly = !gridApi.getGridOption('suppressAggFilteredOnly');
-    const leafNodes = getWeightedAverageLeafNodes(gridApi, groupRowNode, filteredOnly);
-    leafNodes.forEach((rowNode) => {
-        // when editing values might be converted to strings
-        const rawColumnValue = gridApi.getCellValue({ colKey: columnId, rowNode });
-        const columnValue = getNumericValue(rawColumnValue);
-        const rawWeightedColumnValue = gridApi.getCellValue({ colKey: weightColumnId, rowNode });
-        const weightedColumnValue = getNumericValue(rawWeightedColumnValue);
-        if (weightedColumnValue !== null) {
-            weightedColumnValueSum += weightedColumnValue;
+    const { api: gridApi, rowNode: groupRowNode, values } = params;
+    // numerator: Σ(value × weight)
+    let weightedValueSum = 0;
+    // denominator: Σ(weight)
+    let totalWeight = 0;
+    // params.values already respects suppressAggFilteredOnly.
+    // We need the matching child nodes only for leaf rows (to look up weight column values).
+    const childNodes = getMatchingChildNodes(groupRowNode, values.length);
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (value != null && typeof value === 'object') {
+            // sub-group: partial sums already computed by a previous aggregation pass
+            weightedValueSum += value[columnId] ?? 0;
+            totalWeight += value[weightColumnId] ?? 0;
         }
-        if (columnValue !== null) {
-            columnValueSum += columnValue * weightedColumnValue;
+        else {
+            // leaf row: compute value × weight from cell data
+            const childNode = childNodes[i];
+            if (!childNode) {
+                continue;
+            }
+            // values might be strings during editing
+            const columnValue = getNumericValue(value);
+            const weightValue = getNumericValue(gridApi.getCellValue({ colKey: weightColumnId, rowNode: childNode }));
+            if (weightValue !== null) {
+                totalWeight += weightValue;
+            }
+            if (columnValue !== null && weightValue !== null) {
+                weightedValueSum += columnValue * weightValue;
+            }
         }
-    });
-    let result = columnValueSum / weightedColumnValueSum;
-    // 0 / 0 = NaN
-    if (isNaN(result)) {
-        result = 0;
     }
+    const result = totalWeight !== 0 ? weightedValueSum / totalWeight : 0;
     return {
-        // the grid by default uses toString to render values for an object, so this
-        // is a trick to get the default cellRenderer to display the avg value
-        toString: () => {
-            return String(result);
-        },
-        // used for sorting
-        toNumber: function () {
-            return result;
-        },
-        [columnId]: columnValueSum,
-        [weightColumnId]: weightedColumnValueSum,
+        // toString/toNumber let AG Grid's default cell renderer display and sort the value
+        toString: () => String(result),
+        toNumber: () => result,
+        // partial sums stored so parent groups can combine sub-group results
+        [columnId]: weightedValueSum,
+        [weightColumnId]: totalWeight,
     };
 };
+/**
+ * Returns the child node list that corresponds to params.values.
+ * When suppressAggFilteredOnly is false, params.values comes from childrenAfterFilter.
+ * When true, it comes from childrenAfterGroup (all children).
+ * We match by length to pick the right list without checking the grid option directly.
+ */
+function getMatchingChildNodes(groupRowNode, valueCount) {
+    if (groupRowNode.childrenAfterFilter?.length === valueCount) {
+        return groupRowNode.childrenAfterFilter;
+    }
+    return groupRowNode.childrenAfterGroup ?? [];
+}

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -223,6 +223,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
     redrawBody(): void;
     refreshHeader(): void;
     redrawRows(rowNodes?: IRowNode[]): void;
+    refreshGridHeader(): void;
     redrawRow(rowNode: IRowNode): void;
     refreshCell(rowNode: IRowNode, column: string | any, forceUpdate: boolean, suppressFlash?: boolean): void;
     refreshCells(rowNode: IRowNode, columns: (string | Column)[], forceUpdate: boolean, suppressFlash?: boolean): void;

package/src/agGrid/AdaptableAgGrid.js

@@ -957,6 +957,7 @@ export class AdaptableAgGrid {
                         if (rowGroupDisplayType === 'single') {
                             return true;
                         }
+                        // this is required because of AG Grid bug, see https://github.com/AdaptableTools/adaptable/issues/3212
                         if (rowGroupDisplayType === 'multi') {
                             const groupedColumnFilterConfig = this.api.layoutApi.internalApi.areAllGroupedColumnsFilterable();
                             if (groupedColumnFilterConfig.floatingFilter) {
@@ -1082,7 +1083,7 @@ export class AdaptableAgGrid {
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'aggFuncs', (original_aggFuncs) => {
             const aggregationFunctions = original_aggFuncs || {};
             aggregationFunctions[ONLY_AGG_FN_NAME] = (params) => {
-                return only(params, params.column.getColId());
+                return only(params);
             };
             aggregationFunctions[WEIGHTED_AVERAGE_AGG_FN_NAME] = (params) => {
                 const columnId = params.column.getColId();
@@ -1612,6 +1613,12 @@ export class AdaptableAgGrid {
         const perfNewAdaptableStore = this.logger.beginPerf(`initAdaptableStore()`);
         const initAdaptableStoreMarker = getMarker(this.adaptableOptions.adaptableId).track.Init.label.InitStore.start();
         const adaptableStore = new AdaptableStore(this);
+        adaptableStore.onBeforeAny((eventName, data) => {
+            if (this.isReady) {
+                this.api.eventApi.internalApi.fireBeforeAdaptableStateChangeEvent(data.action, data.state);
+            }
+            this.forPlugins((plugin) => plugin.onBeforeStoreEvent?.(eventName, data, this.adaptableStore));
+        });
         adaptableStore.onAny((eventName, data) => {
             if (this.isReady) {
                 this.api.eventApi.internalApi.fireAdaptableStateChangedEvent(data.action, data.state, data.newState);
@@ -2260,6 +2267,9 @@ export class AdaptableAgGrid {
             this.logger.consoleError('AG Grid redrawRows failed to locate some row nodes.', rowNodes, ex);
         }
     }
+    refreshGridHeader() {
+        this.agGridAdapter.getAgGridApi().refreshHeader();
+    }
     redrawRow(rowNode) {
         this.redrawRows([rowNode]);
     }

package/src/env.js

@@ -1,5 +1,5 @@
 export default {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1771927464818 || Date.now(),
-    VERSION: "22.0.0" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1772179361165 || Date.now(),
+    VERSION: "22.0.1-canary.1" || '--current-version--',
 };

package/src/types.d.ts

@@ -139,6 +139,7 @@ export type { ThemeChangedInfo } from './Api/Events/ThemeChanged';
 export type { DashboardChangedInfo } from './Api/Events/DashboardChanged';
 export type { ScheduleTriggeredInfo } from './Api/Events/ScheduleTriggered';
 export type { AdaptableStateChangedInfo } from './Api/Events/AdaptableStateChanged';
+export type { BeforeAdaptableStateChangeInfo } from './Api/Events/BeforeAdaptableStateChange';
 export type { CommentChangedInfo } from './Api/Events/CommentChanged';
 export type { Fdc3MessageInfo, Fdc3MessageSentInfo, Fdc3MessageReceivedInfo, } from './Api/Events/Fdc3MessageInfo';
 export type { AdaptableState, AdaptablePersistentState, AdaptableTransientState, } from './AdaptableState/AdaptableState';