@adaptabletools/adaptable 23.0.0-canary.4 → 23.0.0-canary.5

package/src/View/Theme/ThemePopup.d.ts

@@ -1,19 +1,7 @@
 import * as React from 'react';
-import * as ThemeRedux from '../../Redux/ActionsReducers/ThemeRedux';
 import { ModuleViewPopupProps } from '../Components/SharedProps/ModuleViewPopupProps';
-import { AdaptableTheme } from '../../AdaptableState/ThemeState';
-interface ThemePopupProps extends ModuleViewPopupProps<ThemePopupComponent> {
-    CurrentTheme: string;
-    UserThemes: AdaptableTheme[];
-    SelectTheme: (newTheme: string) => ThemeRedux.ThemeSelectAction;
-    hideShowInWindow?: boolean;
-}
-declare class ThemePopupComponent extends React.Component<ThemePopupProps, {}> {
+declare class ThemePopupComponent extends React.Component<ModuleViewPopupProps<ThemePopupComponent>, {}> {
     render(): React.JSX.Element;
-    onChangeTheme(value: string): void;
-    handleCreateNewTheme: (variant: "dark" | "light") => void;
 }
-export declare let ThemePopup: import("react-redux").ConnectedComponent<typeof ThemePopupComponent, {
-    [x: string]: any;
-}>;
+export declare let ThemePopup: typeof ThemePopupComponent;
 export {};

package/src/View/Theme/ThemePopup.js

@@ -1,47 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
-import { connect } from 'react-redux';
-import * as ThemeRedux from '../../Redux/ActionsReducers/ThemeRedux';
 import { PopupPanel } from '../Components/Popups/AdaptablePopup/PopupPanel';
 import FormLayout, { FormRow } from '../../components/FormLayout';
-import ObjectFactory from '../../Utilities/ObjectFactory';
-import { ACCESS_LEVEL_READ_ONLY } from '../../Utilities/Constants/GeneralConstants';
 import { ThemeSelector } from './ThemeSelector';
 import { Box } from '../../components/Flex';
 class ThemePopupComponent extends React.Component {
     render() {
-        const isCustomTheme = this.props.api.themeApi
-            .getUserThemes()
-            .some((theme) => theme.Name === this.props.CurrentTheme);
-        const disabled = this.props.accessLevel === ACCESS_LEVEL_READ_ONLY;
         return (_jsx(PopupPanel, { headerText: this.props.moduleInfo.FriendlyName, glyphicon: this.props.moduleInfo.Glyph, infoLink: this.props.moduleInfo.HelpPage, infoLinkDisabled: !this.props.api.internalApi.isDocumentationLinksDisplayed(), children: _jsx(FormLayout, { children: _jsx(FormRow, { label: "Select Current Theme:", children: _jsx(Box, { className: "twa:max-w-[150px]", children: _jsx(ThemeSelector, {}) }) }) }) }));
     }
-    onChangeTheme(value) {
-        this.props.SelectTheme(value);
-    }
-    handleCreateNewTheme = (variant) => {
-        let nthItem = this.props.UserThemes.length + 1;
-        let name = 'Custom-Theme-' + nthItem;
-        // make sure it is unique
-        while (this.props.UserThemes.some((theme) => theme.Name === name)) {
-            nthItem++;
-            name = 'Custom-Theme-' + nthItem;
-        }
-        const newTheme = ObjectFactory.CreateEmptyTheme(name);
-        newTheme.Variant = variant;
-        this.props.api.themeApi.addUserTheme(newTheme);
-        this.props.api.themeApi.loadTheme(newTheme.Name);
-    };
-}
-function mapStateToProps(state, ownProps) {
-    return {
-        CurrentTheme: state.Theme.CurrentTheme,
-        UserThemes: state.Theme.UserThemes,
-    };
-}
-function mapDispatchToProps(dispatch) {
-    return {
-        SelectTheme: (newTheme) => dispatch(ThemeRedux.ThemeSelect(newTheme)),
-    };
 }
-export let ThemePopup = connect(mapStateToProps, mapDispatchToProps)(ThemePopupComponent);
+export let ThemePopup = ThemePopupComponent;

package/src/View/UIHelper.js

@@ -314,7 +314,7 @@ export function getButtonColourForAdaptableAlerts(adaptableAlerts, messageTypeCo
 }
 export function getButtonTextColourForArrayandMessageType(adaptableAlerts, messageType) {
     if (ArrayExtensions.IsNullOrEmpty(adaptableAlerts)) {
-        return 'text-on-primary';
+        return 'primary-foreground';
     }
     return this.getButtonTextColourForMessageType(messageType);
 }

package/src/View/Wizard/OnePageAdaptableWizard.js

@@ -1,11 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as React from 'react';
 import { useState } from 'react';
 import { useDispatch } from 'react-redux';
 import * as NamedQueryRedux from '../../Redux/ActionsReducers/NamedQueryRedux';
-import SimpleButton from '../../components/SimpleButton';
 import { useAdaptable } from '../AdaptableContext';
-import { Tabs } from '../../components/Tabs';
+import { Card } from '../../components/Card';
+import { ButtonEdit } from '../Components/Buttons/ButtonEdit';
 import { NamedQueryContext, } from '../../components/ExpressionEditor/NamedQueryContext';
 import { OnePageWizard, useOnePageWizardContext } from './OnePageWizards';
 import kebabCase from '../../Utilities/utils/kebabCase';
@@ -74,20 +74,9 @@ export const OnePageAdaptableWizard = (props) => {
     return (_jsx(OnePageAdaptableWizardContext.Provider, { value: extraContext, children: _jsx(NamedQueryContext.Provider, { value: { namedQuery, setNamedQuery }, children: _jsx(OnePageWizard, { ...props, name: name, sections: sections, onFinish: handleClickFinish, moduleName: props.moduleName ?? props.moduleInfo.FriendlyName }) }) }));
 };
 export const OnePageWizardSummary = () => {
-    const { sections, data, api, moduleInfo } = useOnePageAdaptableWizardContext();
-    const { setCurrentSection } = useOnePageWizardContext();
-    const [namedQuery] = useState(false);
-    const renderEdit = (index) => (_jsx(SimpleButton, { className: "twa:px-1 twa:inline-block twa:text-2 twa:underline", variant: "text", onClick: () => {
-            setCurrentSection(index);
-        }, children: "edit" }));
-    const extraContext = {
-        data,
-        api,
-        namedQuery,
-        moduleInfo: moduleInfo,
-        sections,
-    };
-    return (_jsx(Box, { className: "ab-OnePageWizardSummary twa:flex twa:flex-col twa:gap-2", children: sections
+    const { data, api } = useOnePageAdaptableWizardContext();
+    const { sections: visibleSections, setCurrentSection } = useOnePageWizardContext();
+    return (_jsx(Box, { className: "ab-OnePageWizardSummary twa:flex twa:flex-col twa:gap-3", children: visibleSections
             .map((section, index) => {
             if (section === '-') {
                 return null;
@@ -95,10 +84,7 @@ export const OnePageWizardSummary = () => {
             if (!section.renderSummary) {
                 return null;
             }
-            if (section.isVisible && !section.isVisible(data, api, extraContext)) {
-                return null;
-            }
-            return (_jsx(_Fragment, { children: _jsxs(Tabs, { keyboardNavigation: false, children: [_jsxs(Tabs.Tab, { children: [section.title, " ", renderEdit(index)] }), _jsx(Tabs.Content, { children: section.renderSummary(data, api) })] }, index) }));
+            return (_jsxs(Card, { shadow: false, children: [_jsxs(Card.Title, { className: "twa:w-full", children: [_jsx(Box, { className: "twa:font-medium twa:flex-1", children: section.title }), _jsx(ButtonEdit, { onClick: () => setCurrentSection(index) })] }), _jsx(Card.Body, { className: "twa:p-1", children: section.renderSummary?.(data, api) })] }, `${section.title}-${index}`));
         })
             .filter(Boolean) }));
 };

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -360,6 +360,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private hasFloatingFilterOnAtLeastOneColumn;
     getChartRef(chartId: string): ChartRef;
     updateLayoutInManagerAfterStoreHasChanged(layout?: Layout): void;
+    private getActiveAdaptableAggFuncForCol;
     private onRowDataChanged;
     private onCellDataChanged;
     private isUndoChange;

package/src/agGrid/AdaptableAgGrid.js

@@ -78,10 +78,7 @@ import { AgGridOptionsService } from './AgGridOptionsService';
 import { parseDateValue } from '../Utilities/Helpers/DateHelper';
 import { AgGridColumnAdapter } from './AgGridColumnAdapter';
 import getScrollbarSize from '../Utilities/getScrollbarSize';
-import { ONLY_AGG_FN_NAME } from '../AdaptableState/Common/AggregationColumns';
-import { computeParameterizedAggregation, getParameterizedAggregationDefinitions, } from '../Aggregation/ParameterizedAggregationRegistry';
-import { getParameterizedAggForColumn } from '../Aggregation/parameterizedAggregationHelpers';
-import { getParameterizedAggregationHeaderParenthesisValue } from '../Aggregation/parameterizedAggregationHeader';
+import { ONLY_AGG_FN_NAME, WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../AdaptableState/Common/AggregationColumns';
 import { RowFormService } from '../Utilities/Services/RowFormService';
 import { ADAPTABLE_PUBLISH_TIMESTAMP } from '../EnvVars';
 import { AdaptableUpgradeHelper } from '../migration/AdaptableUpgradeHelper';
@@ -90,10 +87,11 @@ import { AdaptableLoadingScreen } from '../View/Components/Popups/AdaptableLoadi
 import { createElement } from 'react';
 import { createAgStatusPanelComponent } from '../Utilities/createAgStatusPanelComponent';
 import { only } from '../Utilities/only';
+import { weightedAverage } from '../Utilities/weightedAverage';
 import { ROW_SUMMARY_ROW_ID } from '../AdaptableState/Common/RowSummary';
 import { FlashingCellService } from '../Utilities/Services/FlashingCellService';
 import { AgGridExportAdapter } from './AgGridExportAdapter';
-import { checkForDuplicateColumns, getLayoutRowGroupValuesExceptionGroupKeys, isPivotLayout, layoutModelToLayoutState, layoutStateToLayoutModel, normalizeLayout, } from '../Api/Implementation/LayoutHelpers';
+import { checkForDuplicateColumns, resetLayoutHelperErrorOnceMessages, getLayoutRowGroupValuesExceptionGroupKeys, isPivotLayout, layoutModelToLayoutState, layoutStateToLayoutModel, normalizeLayout, } from '../Api/Implementation/LayoutHelpers';
 import { LayoutManager } from '../layout-manager/src';
 import { rowGroupDisplayTypeToGridOption } from '../layout-manager/src/rowGroupDisplayType';
 import { isPivotLayoutModel } from '../layout-manager/src/isPivotLayoutModel';
@@ -354,6 +352,7 @@ export class AdaptableAgGrid {
             this._rawAdaptableOptions.adaptableId = `adaptable_id_${Date.now()}`;
         }
         this.logger = this.logger ?? new AdaptableLogger(this._rawAdaptableOptions.adaptableId);
+        resetLayoutHelperErrorOnceMessages();
         const adaptableId = this._rawAdaptableOptions.adaptableId;
         const initMarker = getMarker(adaptableId).track.Init.label.Init.start();
         const perfInitAdaptableAgGrid = this.logger.beginPerf(`Adaptable._initAdaptableAgGrid()`);
@@ -899,16 +898,7 @@ export class AdaptableAgGrid {
             // #customize_header
             const defaultColDef = { ...original_defaultColDef };
             defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
-                let columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(params);
-                const currentLayout = this.api.layoutApi.getCurrentLayout();
-                if (params.column &&
-                    !currentLayout.SuppressAggFuncInHeader &&
-                    params.location === 'header') {
-                    const parameterizedParenthesisValue = getParameterizedAggregationHeaderParenthesisValue(this.api, params.column.getColId(), currentLayout);
-                    if (parameterizedParenthesisValue) {
-                        columnHeaderName = parameterizedParenthesisValue;
-                    }
-                }
+                const columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(params);
                 const formattedHeaderName = this.api.formatColumnApi.internalApi.formatColumnHeaderName(columnHeaderName, params);
                 return formattedHeaderName;
             });
@@ -1122,16 +1112,17 @@ export class AdaptableAgGrid {
             aggregationFunctions[ONLY_AGG_FN_NAME] = (params) => {
                 return only(params);
             };
-            getParameterizedAggregationDefinitions().forEach((definition) => {
-                aggregationFunctions[definition.agGridAggFuncName] = (params) => {
-                    const columnId = params.column.getColId();
-                    const parameterizedAggFunc = getParameterizedAggForColumn(columnId, this.api.layoutApi.getCurrentLayout());
-                    if (!parameterizedAggFunc || parameterizedAggFunc.type !== definition.type) {
-                        return undefined;
-                    }
-                    return computeParameterizedAggregation(params, params.colDef.colId, parameterizedAggFunc);
-                };
-            });
+            aggregationFunctions[WEIGHTED_AVERAGE_AGG_FN_NAME] = (params) => {
+                const columnId = params.column.getColId();
+                const adaptableAggFunc = this.getActiveAdaptableAggFuncForCol(columnId);
+                if (!adaptableAggFunc) {
+                    return undefined;
+                }
+                if (adaptableAggFunc.type === 'weightedAverage') {
+                    return weightedAverage(params, params.colDef.colId, adaptableAggFunc.weightedColumnId);
+                }
+                return undefined;
+            };
             return aggregationFunctions;
         });
         /**
@@ -4040,6 +4031,25 @@ export class AdaptableAgGrid {
             ],
         });
     }
+    getActiveAdaptableAggFuncForCol(columnId) {
+        if (!columnId) {
+            return null;
+        }
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        const aggregationFunctionsColumnsMap = (isPivotLayout(currentLayout)
+            ? currentLayout.PivotAggregationColumns
+            : currentLayout.TableAggregationColumns).reduce((acc, col) => {
+            acc[col.ColumnId] = col.AggFunc;
+            return acc;
+        }, {});
+        const adaptableAggFunc = aggregationFunctionsColumnsMap[columnId];
+        if (typeof adaptableAggFunc === 'object' &&
+            'type' in adaptableAggFunc &&
+            adaptableAggFunc.type === 'weightedAverage') {
+            return adaptableAggFunc;
+        }
+        return null;
+    }
     onRowDataChanged({ rowNode, oldData, newData, }) {
         if (oldData == null || oldData == undefined) {
             return;

package/src/agGrid/AgGridAdapter.d.ts

@@ -50,6 +50,7 @@ export declare class AgGridAdapter {
     deriveSelectedRowInfoFromAgGrid(): SelectedRowInfo;
     isPinnedRowNode(rowNode: IRowNode): boolean;
     createAdaptableColumnFromAgGridColumn(agGridColumn: Column, colsToGroups: Record<string, AdaptableColumnGroup>): AdaptableColumn;
+    private getUserAllowedAggFuncs;
     private deriveAdaptableColumnDataType;
     private isColumnReadonly;
     private isColumnFieldonly;
@@ -57,7 +58,6 @@ export declare class AgGridAdapter {
     private isColumnRowGroupable;
     private isColumnPivotable;
     private isColumnAggregetable;
-    private getUserAllowedAggFuncs;
     private getColumnAggregationFunctions;
     private isTreeColumn;
     private isColumnMoveable;

package/src/agGrid/AgGridAdapter.js

@@ -8,8 +8,7 @@ import { agGridDataTypeDefinitions, ALL_ADAPTABLE_DATA_TYPES } from './agGridDat
 import { isPivotGrandTotal } from '../Api/Implementation/ColumnApiImpl';
 import { isPivotColumnTotal } from '../layout-manager/src/isPivotColumnTotal';
 import { isPivotAggTotalColumn } from '../layout-manager/src/isPivotAggTotalColumn';
-import { getParameterizedAggregationDefinitionByAgGridName } from '../Aggregation/ParameterizedAggregationRegistry';
-import { isParameterizedAggFuncName } from '../Aggregation/ParameterizedAggregationRegistry';
+import { ONLY_AGG_FN_NAME, WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../AdaptableState/Common/AggregationColumns';
 // AG GRID obfuscates its internals, this is (currently) the best way to get hold of its internal services
 const DANGER_AG_GRID_BEANS_MAP = {};
 const getColumnApiModule = () => ColumnApiModule;
@@ -226,9 +225,8 @@ export class AgGridAdapter {
             if (fctName === 'only') {
                 return 'Only';
             }
-            const parameterizedDefinition = getParameterizedAggregationDefinitionByAgGridName(fctName);
-            if (parameterizedDefinition) {
-                return parameterizedDefinition.agGridAggFuncName;
+            if (fctName === 'weightedAvg') {
+                return 'Weighted Average';
             }
             return original_getDefaultFuncLabel.call(this, fctName);
         };
@@ -542,16 +540,23 @@ export class AgGridAdapter {
         abColumn.exportable = this.isColumnExportable(abColumn);
         if (abColumn.aggregatable) {
             abColumn.availableAggregationFunctions = this.getColumnAggregationFunctions(colDef);
-            const userAllowedAggFuncs = this.getUserAllowedAggFuncs(ColumnId);
-            if (userAllowedAggFuncs) {
-                abColumn.userAllowedAggFuncs = userAllowedAggFuncs;
-            }
+            Object.defineProperty(abColumn, 'userAllowedAggFuncs', {
+                get: () => this.getUserAllowedAggFuncs(ColumnId),
+                enumerable: true,
+                configurable: true,
+            });
             if (typeof colDef.aggFunc === 'string') {
                 abColumn.aggregationFunction = colDef.aggFunc;
             }
         }
         return abColumn;
     }
+    getUserAllowedAggFuncs(columnId) {
+        const userColumnAllowed = this._adaptableInstance?.agGridColumnAdapter?.getUserColDefProperty(columnId, 'allowedAggFuncs');
+        const userDefaultColDef = this.getUserGridOptionsProperty('defaultColDef');
+        const userAllowed = userColumnAllowed ?? userDefaultColDef?.allowedAggFuncs;
+        return Array.isArray(userAllowed) ? [...userAllowed] : undefined;
+    }
     deriveAdaptableColumnDataType(agColumn, logWarning = true) {
         // Some columns can have no ID or Title. we return string as a consequence but it needs testing
         if (!agColumn) {
@@ -684,12 +689,6 @@ export class AgGridAdapter {
         }
         return false;
     }
-    getUserAllowedAggFuncs(columnId) {
-        const userColumnAllowed = this._adaptableInstance?.agGridColumnAdapter?.getUserColDefProperty(columnId, 'allowedAggFuncs');
-        const userDefaultColDef = this.getUserGridOptionsProperty('defaultColDef');
-        const userAllowed = userColumnAllowed ?? userDefaultColDef?.allowedAggFuncs;
-        return Array.isArray(userAllowed) ? [...userAllowed] : undefined;
-    }
     getColumnAggregationFunctions(colDef) {
         const defaultAggFuncs = ['sum', 'min', 'max', 'count', 'avg', 'first', 'last'];
         const hasAllowedAggFuncs = Array.isArray(colDef.allowedAggFuncs);
@@ -697,9 +696,20 @@ export class AgGridAdapter {
         const gridOptionsAggFuncs = this.adaptableApi.agGridApi.getGridOption('aggFuncs') || {};
         const gridOptionsAggFuncNames = Object.keys(gridOptionsAggFuncs);
         if (!hasAllowedAggFuncs) {
-            result.push(...gridOptionsAggFuncNames);
+            // we assume gridOptionsAggFuncNames includes 'weightedAvg' and 'only'
+            const customAggFuncNames = gridOptionsAggFuncNames.filter((name) => name !== WEIGHTED_AVERAGE_AGG_FN_NAME && name !== ONLY_AGG_FN_NAME);
+            // 'weightedAvg' is displayed right after 'avg'
+            const avgIndex = result.indexOf('avg');
+            if (avgIndex >= 0) {
+                result.splice(avgIndex + 1, 0, WEIGHTED_AVERAGE_AGG_FN_NAME);
+            }
+            else {
+                result.push(WEIGHTED_AVERAGE_AGG_FN_NAME);
+            }
+            result.push(...customAggFuncNames);
+            // 'only' is always the last element
+            result.push(ONLY_AGG_FN_NAME);
         }
-        result = result.filter((func) => !isParameterizedAggFuncName(func));
         return [...new Set(result)];
     }
     isTreeColumn(isGeneratedRowGroupColumn) {

package/src/agGrid/AgGridColumnAdapter.js

@@ -1,6 +1,7 @@
 import kebabCase from '../Utilities/utils/kebabCase';
 import { resolveDisplayFormat } from '../AdaptableState/Common/AdaptableFormatPresets';
 import merge from '../Utilities/utils/merge';
+import { resolveSparklineOptionsForRender } from '../Utilities/Helpers/SparklineOptionsHelper';
 import { convertAdaptableStyleToCSS, getVariableColor, hasCellBoxStyle, hasCellFontStyle, normalizeStyleForAgGrid, } from '../Utilities/Helpers/StyleHelper';
 import StringExtensions from '../Utilities/Extensions/StringExtensions';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
@@ -26,7 +27,7 @@ import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AgGridFloatingFilterAdapterFactory } from './AgGridFloatingFilterAdapter';
 import { errorOnce } from './AdaptableLogger';
 import { isUnsupportedColumnDataTypeForIconStyle } from '../Utilities/Helpers/iconStyledColumnColumnSupport';
-import { isParameterizedAggFuncName } from '../Aggregation/ParameterizedAggregationRegistry';
+import { isWeightedAverageAggFuncName, } from '../AdaptableState/Common/AggregationColumns';
 /**
  * CSS property keys produced by `convertAdaptableStyleToCSS` from a
  * `CellFontStyle` slice. Used to strip Format-Column-derived font CSS
@@ -552,7 +553,7 @@ export class AgGridColumnAdapter {
             if (styledColumn && !styledColumn.IsSuspended) {
                 if (styledColumn.SparklineStyle) {
                     const sanitizedSparklineOptions = AdaptableHelper.removeAdaptableObjectPrimitives(styledColumn.SparklineStyle.options);
-                    const sparklineOptions = merge({}, userDefined?.sparklineOptions, sanitizedSparklineOptions);
+                    const sparklineOptions = resolveSparklineOptionsForRender(merge({}, userDefined?.sparklineOptions, sanitizedSparklineOptions));
                     return {
                         ...userDefined,
                         sparklineOptions,
@@ -571,8 +572,7 @@ export class AgGridColumnAdapter {
             // Icon Style has its own tooltip vocabulary (`'CellValue'` /
             // `'IconDescription'`) so we handle it before falling through to the
             // numeric tooltip branch.
-            if (styledColumn.IconStyle &&
-                !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType)) {
+            if (styledColumn.IconStyle && !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType)) {
                 const iconTokens = styledColumn.IconStyle.ToolTipText ?? [];
                 if (iconTokens.length === 0) {
                     return undefined;
@@ -650,9 +650,7 @@ export class AgGridColumnAdapter {
                 if (textOptions.includes('CellValue')) {
                     returnValue = String(params.value ?? '');
                 }
-                if (textOptions.includes('PercentageValue') &&
-                    min != undefined &&
-                    max != undefined) {
+                if (textOptions.includes('PercentageValue') && min != undefined && max != undefined) {
                     let percentageValue;
                     if (styledColumn.PercentBarStyle?.ColumnComparison) {
                         const absMax = Math.abs(max);
@@ -661,8 +659,7 @@ export class AgGridColumnAdapter {
                     else {
                         const scaleSpan = max - min;
                         const clamped = Helper.clamp(Number(params.value), min, max);
-                        percentageValue =
-                            scaleSpan === 0 ? 0 : ((clamped - min) / scaleSpan) * 100;
+                        percentageValue = scaleSpan === 0 ? 0 : ((clamped - min) / scaleSpan) * 100;
                     }
                     returnValue += ` (${percentageValue.toFixed(0)}%)`;
                 }
@@ -728,8 +725,7 @@ export class AgGridColumnAdapter {
             if (!abColumn.availableAggregationFunctions) {
                 return undefined;
             }
-            return abColumn.availableAggregationFunctions.filter((func) => !isParameterizedAggFuncName(func));
-            // .filter((func) => func !== ONLY_AGG_FN_NAME);
+            return abColumn.availableAggregationFunctions.filter((func) => !isWeightedAverageAggFuncName(func));
         });
     }
     setupColumnType(columnSetupInfo) {
@@ -1463,8 +1459,7 @@ export class AgGridColumnAdapter {
         // basis when a Gradient cell has a tinted background, even if the user
         // also set `Font.ForeColor` as a baseline.
         const autoContrastColor = gradientStyle?.AutoContrastText && style.color ? style.color : undefined;
-        const iconStyleFontApplies = styledColumn.IconStyle &&
-            !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType);
+        const iconStyleFontApplies = styledColumn.IconStyle && !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType);
         const fontSlot = styledColumn.GradientStyle?.Font ??
             styledColumn.PercentBarStyle?.Font ??
             styledColumn.BulletChartStyle?.Font ??
@@ -1476,8 +1471,7 @@ export class AgGridColumnAdapter {
         if (fontSlot) {
             style = { ...style, ...convertAdaptableStyleToCSS(fontSlot) };
         }
-        const iconStyleCellApplies = styledColumn.IconStyle &&
-            !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType);
+        const iconStyleCellApplies = styledColumn.IconStyle && !isUnsupportedColumnDataTypeForIconStyle(abColumn.dataType);
         const cellSlot = styledColumn.RatingStyle?.Cell ??
             styledColumn.SparklineStyle?.Cell ??
             styledColumn.BadgeStyle?.Cell ??

package/src/agGrid/AgGridMenuAdapter.d.ts

@@ -9,7 +9,6 @@ export declare class AgGridMenuAdapter {
     private get adaptableApi();
     destroy(): void;
     buildColumnMenu(params: GetMainMenuItemsParams, originalGetMainMenuItems: GetMainMenuItems): (DefaultMenuItem | MenuItemDef)[];
-    private injectParameterizedAggregationColumnMenuItems;
     buildContextMenu(params: GetContextMenuItemsParams, originalGetContextMenuItems: GetContextMenuItems): (DefaultMenuItem | MenuItemDef)[];
     private mapAgGridItemTypeToAgGridMenuItem;
     private removeConsecutiveSeparators;

package/src/agGrid/AgGridMenuAdapter.js

@@ -2,8 +2,8 @@ import { isAdaptableElementIcon } from '../components/Icon';
 import { iconToString } from '../components/icons';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 import { MENU_SEPARATOR } from '../Utilities/Constants/GeneralConstants';
-import { buildConsolidatedAggregationColumnMenuItem, findParameterizedAggMenuInsertIndex, isValueAggregationMenuItem, } from '../Aggregation/parameterizedAggregationColumnMenu';
-import { removeColumnAggregationFromLayout, upsertColumnAggregationInLayout, } from '../Aggregation/parameterizedAggregationHelpers';
+import { buildValueAggregationMenuItem } from './buildValueAggregationMenuItem';
+import { createAgGridIcon } from './createAgGridIcon';
 export class AgGridMenuAdapter {
     _adaptableInstance;
     constructor(_adaptableInstance) {
@@ -55,42 +55,25 @@ export class AgGridMenuAdapter {
                 .filter(Boolean);
         }
         // 2. if not, return the default context menu
-        let defaultContextMenu = [
-            ...agGridMenuItems,
+        // AG Grid does not allow customizing the built-in `valueAggSubMenu`, so we
+        // replace it with an Adaptable-built equivalent that also offers a Weighted
+        // Average aggregation (with a submenu to pick the weight column).
+        // Weighted Average is never used in Pivot Layouts, so we leave the AG Grid
+        // default item untouched there.
+        const isPivotLayout = this.adaptableApi.layoutApi.isCurrentLayoutPivot();
+        const mappedAgGridMenuItems = agGridMenuItems.map((itemName) => itemName === 'valueAggSubMenu' && !isPivotLayout
+            ? {
+                ...buildValueAggregationMenuItem(this.adaptableApi, menuContext),
+                icon: createAgGridIcon('aggregation'),
+            }
+            : itemName);
+        const defaultContextMenu = [
+            ...mappedAgGridMenuItems,
             'separator',
             ...defaultColumnMenuStructure.map((adaptableItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(adaptableItem)),
         ];
-        defaultContextMenu = this.injectParameterizedAggregationColumnMenuItems(defaultContextMenu, adaptableColumn);
         return this.removeConsecutiveSeparators(defaultContextMenu);
     }
-    injectParameterizedAggregationColumnMenuItems(menuItems, column) {
-        const consolidatedAggregationMenuItem = buildConsolidatedAggregationColumnMenuItem(this.adaptableApi, column, (columnId, parameterizedAgg) => {
-            this.adaptableApi.layoutApi.setColumnParameterizedAggregation(columnId, parameterizedAgg);
-        }, (columnId, aggFunc) => {
-            this.adaptableApi.layoutApi.updateCurrentLayout((layout) => {
-                if (aggFunc == null) {
-                    removeColumnAggregationFromLayout(layout, columnId);
-                }
-                else {
-                    upsertColumnAggregationInLayout(layout, columnId, aggFunc);
-                }
-                return layout;
-            });
-            this.adaptableApi.agGridApi.setColumnAggFunc(columnId, aggFunc);
-        });
-        if (!consolidatedAggregationMenuItem) {
-            return menuItems;
-        }
-        consolidatedAggregationMenuItem.icon = this.mapAdaptableIconToAgGridIcon({ name: 'equation' });
-        const originalValueAggMenuIndex = menuItems.findIndex((item) => isValueAggregationMenuItem(item));
-        const menuItemsWithoutValueAgg = menuItems.filter((item) => !isValueAggregationMenuItem(item));
-        const result = [...menuItemsWithoutValueAgg];
-        const insertIndex = originalValueAggMenuIndex !== -1
-            ? Math.min(originalValueAggMenuIndex, result.length)
-            : findParameterizedAggMenuInsertIndex(menuItemsWithoutValueAgg);
-        result.splice(insertIndex, 0, consolidatedAggregationMenuItem);
-        return result;
-    }
     buildContextMenu(params, originalGetContextMenuItems) {
         if (!params.column) {
             return [];
@@ -269,7 +252,7 @@ export class AgGridMenuAdapter {
                     ? () => this.adaptableApi.internalApi.dispatchReduxAction(fullMenuItem.reduxAction)
                     : undefined,
             icon: this.mapAdaptableIconToAgGridIcon(fullMenuItem.icon, {
-                fill: 'var(--ab-color-text-on-primary)',
+                fill: 'var(--ab-color-primary-foreground)',
             }),
             subMenu: fullMenuItem.subItems?.map((subMenuItem) => this.mapAdaptableMenuItemToAgGridMenuDefinition(subMenuItem)),
         };
@@ -282,7 +265,7 @@ export class AgGridMenuAdapter {
             return {
                 name: customMenuItem.label,
                 icon: this.mapAdaptableIconToAgGridIcon(customMenuItem.icon, {
-                    fill: 'var(--ab-color-text-on-primary)',
+                    fill: 'var(--ab-color-primary-foreground)',
                 }),
                 disabled: customMenuItem.disabled,
                 subMenu: !customMenuItem.disabled
@@ -310,7 +293,7 @@ export class AgGridMenuAdapter {
             name: userMenuItem.label,
             action: () => (userMenuItem.onClick ? userMenuItem.onClick(menuContext) : null),
             icon: this.mapAdaptableIconToAgGridIcon(userMenuItem.icon, {
-                fill: 'var(--ab-color-text-on-primary)',
+                fill: 'var(--ab-color-primary-foreground)',
             }),
             disabled: userMenuItem.disabled,
             subMenu: userMenuItem.subMenuItems
@@ -735,7 +718,7 @@ export class AgGridMenuAdapter {
         }
         else {
             return iconToString(icon, {
-                fill: 'var(--ab-color-text-on-primary)',
+                fill: 'var(--ab-color-primary-foreground)',
             });
         }
     }

package/src/agGrid/buildValueAggregationMenuItem.d.ts

@@ -0,0 +1,19 @@
+import { MenuItemDef } from 'ag-grid-enterprise';
+import { AdaptableApi } from '../types';
+import { ColumnMenuContext } from '../AdaptableState/Common/Menu';
+/**
+ * Builds the replacement for AG Grid's built-in `valueAggSubMenu` column menu item.
+ *
+ * AG Grid does not allow customizing the built-in submenu, so we rebuild an
+ * equivalent one: the column's existing aggregation functions plus a
+ * `Weighted Average` item whose submenu lists the numeric columns that can be
+ * used as the weight parameter.
+ *
+ * Both standard and weighted selections persist through the current Layout
+ * (`updateCurrentLayout`), so the existing `weightedAvg` aggFunc can read the
+ * chosen `weightedColumnId` back from the Layout.
+ *
+ * Weighted Average is never used in Pivot Layouts, so this only deals with the
+ * Table Layout aggregations and the caller skips it entirely in Pivot mode.
+ */
+export declare function buildValueAggregationMenuItem(adaptableApi: AdaptableApi, menuContext: ColumnMenuContext): MenuItemDef;