@adaptabletools/adaptable 23.0.0-canary.1 → 23.0.0-canary.10

package/src/View/Wizard/WizardTypeSelection.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Input from '../../components/Input';
+import { Box } from '../../components/Flex';
+import { Card } from '../../components/Card';
+import { cn } from '../../lib/utils';
+export const WIZARD_TYPE_SELECTION_PREVIEW_FRAME_CLASS = 'twa:flex twa:w-full twa:min-h-[32px] twa:items-center twa:justify-center twa:overflow-hidden twa:rounded-standard twa:border twa:border-[color-mix(in_srgb,var(--ab-color-foreground)_15%,transparent)] twa:bg-[color-mix(in_srgb,var(--ab-color-primary)_35%,transparent)] twa:px-2 twa:py-1';
+export const getWizardTypeSelectionGridColumns = (choiceCount) => choiceCount === 4 ? 2 : 3;
+export const WizardTypeSelectionCard = ({ label, description, selected, disabled, disabledTooltip, dataName, minHeightClassName = 'twa:min-h-[108px]', onSelect, children, footer, }) => {
+    const handleActivate = () => {
+        if (!disabled) {
+            onSelect();
+        }
+    };
+    return (_jsxs(Box, { role: "radio", tabIndex: disabled ? -1 : 0, "aria-checked": selected, "aria-disabled": disabled, "data-name": dataName, className: cn('ab-WizardTypeSelectionCard group twa:relative twa:h-full twa:rounded-standard twa:border twa:border-primarydark/32 twa:bg-card twa:text-card-foreground twa:outline-none twa:transition-colors twa:focus-visible:ring-2 twa:focus-visible:ring-accent', minHeightClassName, disabled
+            ? 'twa:cursor-not-allowed twa:opacity-60'
+            : 'twa:cursor-pointer hover:twa:border-accent/55 hover:twa:bg-accent/5', selected &&
+            'twa:after:pointer-events-none twa:after:absolute twa:after:inset-0 twa:after:rounded-standard twa:after:border-2 twa:after:border-[var(--ab-cmp-wizard-type-selection-card__selected-border)] twa:after:bg-[var(--ab-cmp-wizard-type-selection-card__selected-overlay)]'), onClick: handleActivate, onKeyDown: (event) => {
+            if (disabled) {
+                return;
+            }
+            if (event.key === 'Enter' || event.key === ' ') {
+                event.preventDefault();
+                onSelect();
+            }
+        }, children: [_jsx(Box, { "aria-hidden": true, className: cn('twa:pointer-events-none twa:absolute twa:top-2.5 twa:right-2.5 twa:z-10 twa:size-4 twa:rounded-full twa:border-2 twa:transition-colors', selected
+                    ? 'twa:border-[var(--ab-cmp-wizard-type-selection-card__selected-border)] twa:bg-[var(--ab-cmp-wizard-type-selection-card__selected-border)]'
+                    : 'twa:border-primarydark/35 twa:bg-base group-hover:twa:border-accent/55'), children: selected ? (_jsx(Box, { className: "twa:absolute twa:inset-0 twa:m-auto twa:size-1.5 twa:rounded-full twa:bg-[var(--ab-cmp-wizard-type-selection-card__selected-indicator-inner)]" })) : null }), _jsxs(Card, { shadow: false, style: { backgroundColor: 'transparent' }, className: "twa:flex twa:h-full twa:flex-col twa:justify-between twa:p-3 twa:pr-7", gap: 0, children: [_jsx(Box, { className: "twa:font-medium", children: label }), children, description || disabledTooltip ? (_jsxs(Box, { children: [description ? (_jsx(Box, { className: "twa:text-xs twa:leading-snug twa:opacity-70", children: description })) : null, disabled && disabledTooltip ? (_jsx(Box, { className: "twa:mt-1 twa:text-1 twa:leading-snug twa:italic twa:opacity-80", children: disabledTooltip })) : null] })) : null, footer] })] }));
+};
+export const WizardTypeSelectionSection = ({ headingId, title, intro, columns, dataName, className, children }) => (_jsxs(Card, { shadow: false, gap: 1, className: cn('twa:flex-1 twa:min-h-0', className), children: [_jsxs(Card.Title, { gap: 1, border: false, className: "twa:flex-col twa:items-start twa:px-1 twa:pb-1", children: [_jsx(Box, { id: headingId, className: "twa:font-medium", children: title }), _jsx(Box, { className: "twa:mt-1.5 twa:text-xs twa:font-normal twa:opacity-70", children: intro })] }), _jsx(Card.Body, { className: "twa:min-h-0 twa:overflow-y-auto twa:p-1 twa:pt-0", children: _jsx(Box, { "data-name": dataName, className: cn('twa:grid twa:gap-2', columns === 2 ? 'twa:grid-cols-2' : 'twa:grid-cols-3'), role: "radiogroup", "aria-labelledby": headingId, children: children }) })] }));
+export const WizardNameFieldSection = ({ value, onChange, inputDataName = 'wizard-name', placeholder = 'Enter Name', }) => (_jsxs(Card, { shadow: false, gap: 1, className: "twa:bg-card twa:text-card-foreground", children: [_jsx(Card.Title, { gap: 1, border: false, className: "twa:px-1 twa:pb-1", children: _jsx(Box, { className: "twa:font-medium", children: "Name" }) }), _jsx(Card.Body, { className: "twa:p-1", children: _jsx(Input, { className: "twa:w-full twa:max-w-[420px]", "data-name": inputDataName, onChange: onChange, placeholder: placeholder, value: value }) })] }));
+export const WizardTypeSelectionPreviewFrame = ({ children, }) => (_jsx(Box, { "aria-hidden": true, className: WIZARD_TYPE_SELECTION_PREVIEW_FRAME_CLASS, children: children }));

package/src/View/Wizard/rowGroupSummaryTags.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { AdaptableApi, Layout } from '../../types';
+export declare const TableRowGroupSummaryTags: React.FC<{
+    layout: Layout;
+    api: AdaptableApi;
+}>;
+export declare const PivotRowGroupSummaryTags: React.FC<{
+    layout: Layout;
+    api: AdaptableApi;
+}>;
+export declare const TableRowGroupSummaryView: React.FC<{
+    layout: Layout;
+    api: AdaptableApi;
+}>;
+export declare const PivotRowGroupSummaryView: React.FC<{
+    layout: Layout;
+    api: AdaptableApi;
+}>;

package/src/View/Wizard/rowGroupSummaryTags.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ColumnTag, Tag } from '../../components/Tag';
+import { Flex } from '../../components/Flex';
+import { getRowGroupBehaviorLabel, getRowGroupDisplayTypeLabel, } from '../../Strategy/Utilities/Layout/rowGroupSummaryHelpers';
+export const TableRowGroupSummaryTags = ({ layout, api, }) => {
+    const columnIds = layout.RowGroupedColumns ?? [];
+    return (_jsxs(Flex, { flexWrap: "wrap", alignItems: "center", className: "twa:gap-1", children: [!columnIds.length ? (_jsx(Tag, { children: "No Row Grouped Columns" })) : (columnIds.map((columnId) => (_jsx(ColumnTag, { children: api.columnApi.getFriendlyNameForColumnId(columnId) }, columnId)))), _jsxs(Tag, { children: ["Display Type: ", getRowGroupDisplayTypeLabel(layout)] }), _jsxs(Tag, { children: ["Behaviour: ", getRowGroupBehaviorLabel(layout)] })] }));
+};
+export const PivotRowGroupSummaryTags = ({ layout, api, }) => {
+    const columnIds = layout.PivotGroupedColumns ?? [];
+    return (_jsxs(Flex, { flexWrap: "wrap", alignItems: "center", className: "twa:gap-1", children: [!columnIds.length ? (_jsx(Tag, { children: "No Row Grouped Columns" })) : (columnIds.map((columnId) => (_jsx(ColumnTag, { children: api.columnApi.getFriendlyNameForColumnId(columnId) }, columnId)))), _jsxs(Tag, { children: ["Behaviour: ", getRowGroupBehaviorLabel(layout)] })] }));
+};
+export const TableRowGroupSummaryView = (props) => _jsx(TableRowGroupSummaryTags, { ...props });
+export const PivotRowGroupSummaryView = (props) => _jsx(PivotRowGroupSummaryTags, { ...props });

package/src/View/Wizard/scopeSummaryTags.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { ColumnScope } from '../../AdaptableState/Common/ColumnScope';
+export { getScopeViewItemsTagVariant as getScopeSummaryTagVariant } from '../../components/Tag/columnScopeTagHelpers';
+export declare const ScopeSummaryTags: React.FC<{
+    scope: ColumnScope;
+}>;

package/src/View/Wizard/scopeSummaryTags.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getColumnTypeFriendlyName } from '../../AdaptableState/Common/AdaptableColumn';
+import { Tag, TagList } from '../../components/Tag';
+import { Flex } from '../../components/Flex';
+import { useAdaptable } from '../AdaptableContext';
+export { getScopeViewItemsTagVariant as getScopeSummaryTagVariant } from '../../components/Tag/columnScopeTagHelpers';
+export const ScopeSummaryTags = ({ scope }) => {
+    const { api } = useAdaptable();
+    const scopeApi = api.columnScopeApi;
+    const columnsInScope = scopeApi.getColumnsInScope(scope);
+    if (scopeApi.scopeIsAll(scope)) {
+        return _jsx(Tag, { children: "All Columns" });
+    }
+    if ('ColumnIds' in scope) {
+        if (!columnsInScope.length) {
+            return _jsx(Tag, { children: "None" });
+        }
+        return (_jsx(TagList, { tags: columnsInScope.map((c) => c.friendlyName), variant: "column" }));
+    }
+    if ('DataTypes' in scope) {
+        if (!scope.DataTypes.length) {
+            return _jsx(Tag, { children: "None" });
+        }
+        return (_jsx(Flex, { flexWrap: "wrap", className: "twa:gap-1", children: scope.DataTypes.map((dataType) => (_jsx(Tag, { children: getColumnTypeFriendlyName(dataType) }, dataType))) }));
+    }
+    if ('ColumnTypes' in scope) {
+        if (!scope.ColumnTypes.length) {
+            return _jsx(Tag, { children: "None" });
+        }
+        return (_jsx(Flex, { flexWrap: "wrap", className: "twa:gap-1", children: scope.ColumnTypes.map((columnType) => (_jsx(Tag, { children: columnType }, columnType))) }));
+    }
+    return _jsx(Tag, { children: "None" });
+};

package/src/View/renderWithAdaptableContext.js

@@ -1,8 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Provider } from 'react-redux';
 import AdaptableContext from './AdaptableContext';
-import { WithAdaptableComputedCSSVars } from './AdaptableComputedCSSVarsContext';
 import { TooltipProvider } from "../components/ui/tooltip";
 export const renderWithAdaptableContext = (children, adaptable) => {
-    return (_jsx(TooltipProvider, { delay: 300, children: _jsx(Provider, { store: adaptable.adaptableStore.TheStore, children: _jsx(WithAdaptableComputedCSSVars, { children: _jsx(AdaptableContext.Provider, { value: adaptable, children: children }) }) }) }));
+    return (_jsx(TooltipProvider, { delay: 300, children: _jsx(Provider, { store: adaptable.adaptableStore.TheStore, children: _jsx(AdaptableContext.Provider, { value: adaptable, children: children }) }) }));
 };

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -97,7 +97,6 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private LicenseService;
     private ChartingService;
     private rowListeners;
-    private throttleFilterOnDataChange;
     private debouncedSetSelectedRows;
     private debouncedSetSelectedCells;
     private agGridListenerKeydown;
@@ -361,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

@@ -1,10 +1,9 @@
-import throttle from '../Utilities/utils/throttle';
-import debounce from '../Utilities/utils/debounce';
+import { debounce } from '../Utilities/Helpers/TimingHelper';
 import { createGrid, LocalEventService, } from 'ag-grid-enterprise';
 import { AdaptableLogger } from './AdaptableLogger';
 import { PrimaryKeyDocsLink } from '../Utilities/Constants/DocumentationLinkConstants';
 import StringExtensions from '../Utilities/Extensions/StringExtensions';
-import { applyQuickSearchFindCssVars } from '../Utilities/Helpers/QuickSearchStyleHelper';
+import { applyQuickSearchFindCssVars } from '../Utilities/Helpers/QuickSearchHelper';
 import Emitter from '../Utilities/Emitter';
 import { applyDefaultAdaptableOptions } from '../AdaptableOptions/DefaultAdaptableOptions';
 import { resolveContainerElement } from '../Utilities/resolveContainerElement';
@@ -21,6 +20,7 @@ import { ThemeService } from '../Utilities/Services/ThemeService';
 import { ValidationService } from '../Utilities/Services/ValidationService';
 import { ModuleService } from '../Utilities/Services/ModuleService';
 import { CalculatedColumnExpressionService } from '../Utilities/Services/CalculatedColumnExpressionService';
+import { expandCellDataChangedInfosWithCalculatedColumns } from '../Utilities/Services/CalculatedColumnExpressionService';
 import { QueryLanguageService } from '../Utilities/Services/QueryLanguageService';
 import { AlertService } from '../Utilities/Services/AlertService';
 import { TeamSharingService } from '../Utilities/Services/TeamSharingService';
@@ -78,24 +78,22 @@ 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 { FilterOnDataChangeOptions } from '../AdaptableState/Common/Enums';
 import { ADAPTABLE_PUBLISH_TIMESTAMP } from '../EnvVars';
 import { AdaptableUpgradeHelper } from '../migration/AdaptableUpgradeHelper';
 import { ensureLoadingScreenPortalElement } from '../components/Modal';
 import { AdaptableLoadingScreen } from '../View/Components/Popups/AdaptableLoadingScreen';
 import { createElement } from 'react';
 import { createAgStatusPanelComponent } from '../Utilities/createAgStatusPanelComponent';
-import { only } from '../Utilities/only';
+import { only } from '../AdaptableState/Aggregations/only';
+import { weightedAverage } from '../AdaptableState/Aggregations/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';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, HIDDEN_COLUMN_TYPE, hiddenColDefConfig, PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE, PIVOT_ANY_TOTAL_COLUMN_TYPE, PIVOT_COLUMN_TOTAL_COLUMN_TYPE, PIVOT_GRAND_TOTAL_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
 import { agGridDataTypeDefinitions } from './agGridDataTypeDefinitions';
@@ -105,7 +103,7 @@ import { tagProvidedByAdaptable } from '../Utilities/adaptableOverrideCheck';
 import { AgGridModulesAdapter } from './AgGridModulesAdapter';
 import { getMarker } from '../devTools';
 import { DeepMap } from '@infinite-table/infinite-react';
-import { DateFormatter } from '../Utilities/Helpers/FormatHelper';
+import { DateFormatter } from '../Utilities/Helpers/DisplayFormatHelper';
 import { clearPredicateDefMapMemo } from '../Api/Implementation/PredicateApiImpl';
 import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AdaptableFilterHandler } from './AdaptableFilterHandler';
@@ -203,7 +201,6 @@ export class AdaptableAgGrid {
     LicenseService;
     ChartingService;
     rowListeners;
-    throttleFilterOnDataChange;
     debouncedSetSelectedRows;
     debouncedSetSelectedCells;
     agGridListenerKeydown;
@@ -355,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()`);
@@ -461,8 +459,7 @@ export class AdaptableAgGrid {
             if (isPivotLayoutModel(layoutModel)) {
                 gridOptions.pivotDefaultExpanded = layoutModel.PivotExpandLevel;
             }
-            gridOptions.groupDisplayType =
-                layoutModel.RowGroupDisplayType === 'multi' ? 'multipleColumns' : 'singleColumn';
+            gridOptions.groupDisplayType = rowGroupDisplayTypeToGridOption(layoutModel.RowGroupDisplayType);
             // fixes issue #3053
             gridOptions.suppressAggFuncInHeader = !!layoutModel.SuppressAggFuncInHeader;
             if (!isPivotLayoutModel(layoutModel) &&
@@ -901,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;
             });
@@ -1124,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;
         });
         /**
@@ -1449,7 +1438,7 @@ export class AdaptableAgGrid {
                 // dataType: 'Number',
                 // AG Grid requires either dataType or numberFormat to be set for Numbers
                 numberFormat: {
-                    format: '0.###############',
+                    format: `#,##0.00`,
                 },
             });
             // store original excel styles, we will have to revert to them after each VISUAL EXPORT
@@ -1699,12 +1688,6 @@ export class AdaptableAgGrid {
             }), true);
             gridContainerElement.addEventListener('mouseleave', (this.agGridListenerMouseLeave = (event) => this._emit('MouseLeave', event)));
         }
-        this.throttleFilterOnDataChange = throttle(
-        // the extra function is to make sure we have a reference to ag-grid-api
-        () => this.agGridAdapter.getAgGridApi()?.onFilterChanged(), this.adaptableOptions.filterOptions.filterActionOnDataChange.throttleDelay, {
-            trailing: true,
-            leading: false,
-        });
         /**
          * Use Case: User has started inline editing but its disabled in Row Form Options
          * Action: Stop editing
@@ -3813,7 +3796,6 @@ export class AdaptableAgGrid {
             this.listenerCellSelectionChanged = null;
             this.listenerGlobalSetRowSelection = null;
             this.listenerSortChanged = null;
-            this.throttleFilterOnDataChange = null;
             const liveGridOptions = this.agGridAdapter.DANGER_getLiveGridOptions();
             if (liveGridOptions) {
                 this.agGridOptionsService.revertGridOptionsPropertiesToUserValue(liveGridOptions, [
@@ -4049,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;
@@ -4133,6 +4134,7 @@ export class AdaptableAgGrid {
      * There are a few things we need to do AFTER we edit a cell and it makes sense to put them in one place
      */
     performPostEditChecks(rowNode, cellDataChangedInfos) {
+        cellDataChangedInfos = expandCellDataChangedInfosWithCalculatedColumns(this.api, cellDataChangedInfos);
         cellDataChangedInfos.forEach((cellDataChangedInfo) => {
             // if a Cell Data Change is undone, log to the Console
             if (cellDataChangedInfo.trigger === 'undo') {
@@ -4290,14 +4292,7 @@ export class AdaptableAgGrid {
         }
     }
     filterOnDataChange() {
-        if (this.adaptableOptions.filterOptions.filterActionOnDataChange.applyFilter ==
-            FilterOnDataChangeOptions.Always) {
-            this.agGridAdapter.getAgGridApi()?.onFilterChanged();
-        }
-        else if (this.adaptableOptions.filterOptions.filterActionOnDataChange.applyFilter ==
-            FilterOnDataChangeOptions.Throttle) {
-            this.throttleFilterOnDataChange();
-        }
+        this.agGridAdapter.getAgGridApi()?.onFilterChanged();
     }
     refreshLayout() {
         const columnDefs = this.agGridAdapter.getColumnDefinitionsInclSpecialColumns();

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) {
@@ -581,11 +586,6 @@ export class AgGridAdapter {
             return 'unknown';
         }
         let dataType = 'unknown';
-        // get the column type if already in store (and not unknown)
-        const existingColumn = this.adaptableApi.columnApi.getColumnWithColumnId(agColumn.getId(), logWarning);
-        if (existingColumn && existingColumn.dataType !== 'unknown') {
-            return existingColumn.dataType;
-        }
         // check for colDef dataType
         const colDefDataType = agColumn.getColDef().cellDataType;
         if (typeof colDefDataType === 'string' && ALL_ADAPTABLE_DATA_TYPES.includes(colDefDataType)) {
@@ -684,12 +684,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 +691,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,7 +1,9 @@
-import kebabCase from '../Utilities/utils/kebabCase';
+import { kebabCase } from '../Utilities/Extensions/StringExtensions';
 import { resolveDisplayFormat } from '../AdaptableState/Common/AdaptableFormatPresets';
-import merge from '../Utilities/utils/merge';
-import { convertAdaptableStyleToCSS, getVariableColor, hasCellBoxStyle, hasCellFontStyle, normalizeStyleForAgGrid, } from '../Utilities/Helpers/StyleHelper';
+import { merge } from '../Utilities/Extensions/ObjectExtensions';
+import { resolveSparklineOptionsForRender } from '../Utilities/Helpers/StyledColumns/SparklineStyleHelper';
+import { hasBarStyleCellTextConfigured } from '../Utilities/Helpers/StyledColumns/BarStylesHelper';
+import { convertAdaptableStyleToCSS, getAutoContrastTextColor, 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';
 import tinycolor from 'tinycolor2';
@@ -11,11 +13,11 @@ import { getBadgeRendererForColumn } from './cellRenderers/BadgeRenderer';
 import { getBulletChartRendererForColumn } from './cellRenderers/BulletChartRenderer';
 import { getRangeBarRendererForColumn } from './cellRenderers/RangeBarRenderer';
 import { getRatingRendererForColumn } from './cellRenderers/RatingRenderer';
-import { shouldRenderStyledColumnOnRow } from './cellRenderers/shouldRenderStyledColumnOnRow';
+import { shouldRenderStyledColumnOnRow } from '../Utilities/Helpers/StyledColumns/StyledColumnHelper';
 import { findIconStyleMappingForValue, getIconRendererForColumn, } from './cellRenderers/IconRenderer';
-import Helper from '../Utilities/Helpers/Helper';
-import { getRuleAlertProperties } from '../Utilities/Helpers/ScheduledAlertHelper';
-import { isNegativeZeroCentredBand, expandGradientCellRanges, gradientStyleRangeLookupValueType, DEFAULT_GRADIENT_MIN_ALPHA, DEFAULT_GRADIENT_MAX_ALPHA, } from '../Utilities/Helpers/StyledColumnGradientHelper';
+import { clamp } from '../Utilities/Extensions/NumberExtensions';
+import { getRuleAlertProperties } from '../Utilities/Helpers/Scheduling/ScheduledAlertHelper';
+import { isNegativeZeroCentredBand, expandGradientCellRanges, gradientStyleRangeLookupValueType, DEFAULT_GRADIENT_MIN_ALPHA, DEFAULT_GRADIENT_MAX_ALPHA, } from '../Utilities/Helpers/StyledColumns/GradientStyleHelper';
 import { AdaptableNumberEditor, AdaptableReactNumberEditor } from './editors/AdaptableNumberEditor';
 import { AdaptableDateEditor, AdaptableReactDateEditor } from './editors/AdaptableDateEditor';
 import { AgGridExportAdapter } from './AgGridExportAdapter';
@@ -25,8 +27,8 @@ import { AdaptableFilterHandler } from './AdaptableFilterHandler';
 import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AgGridFloatingFilterAdapterFactory } from './AgGridFloatingFilterAdapter';
 import { errorOnce } from './AdaptableLogger';
-import { isUnsupportedColumnDataTypeForIconStyle } from '../Utilities/Helpers/iconStyledColumnColumnSupport';
-import { isParameterizedAggFuncName } from '../Aggregation/ParameterizedAggregationRegistry';
+import { isUnsupportedColumnDataTypeForIconStyle } from '../Utilities/Helpers/StyledColumns/IconStyleHelper';
+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 +554,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 +573,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;
@@ -610,7 +611,7 @@ export class AgGridColumnAdapter {
                     if (ratingToolTip.includes('PercentageValue') && ratingMax > 0) {
                         const n = Number(params.value);
                         if (!isNaN(n)) {
-                            const clamped = Helper.clamp(n, 0, ratingMax);
+                            const clamped = clamp(n, 0, ratingMax);
                             const percentageValue = (clamped / ratingMax) * 100;
                             const pct = `${percentageValue.toFixed(0)}%`;
                             returnValue = returnValue ? `${returnValue} (${pct})` : pct;
@@ -650,9 +651,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);
@@ -660,9 +659,8 @@ 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;
+                        const clamped = clamp(Number(params.value), min, max);
+                        percentageValue = scaleSpan === 0 ? 0 : ((clamped - min) / scaleSpan) * 100;
                     }
                     returnValue += ` (${percentageValue.toFixed(0)}%)`;
                 }
@@ -728,8 +726,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) {
@@ -951,10 +948,7 @@ export class AgGridColumnAdapter {
                 // 1. evaluate EditOptions.isCellEditable if provided
                 if (this.adaptableApi.gridApi.internalApi.hasCellEditableAccordingToEditOptions()) {
                     const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, params.column.getColId());
-                    const editOptionsEditability = this.adaptableApi.gridApi.internalApi.isCellEditableAccordingToEditOptions(gridCell, getOriginalColDefEditable());
-                    if (editOptionsEditability) {
-                        return editOptionsEditability;
-                    }
+                    return this.adaptableApi.gridApi.internalApi.isCellEditableAccordingToEditOptions(gridCell, getOriginalColDefEditable());
                 }
                 // 2. otherwise, fallback to colDef.editable
                 return getOriginalColDefEditable();
@@ -1433,11 +1427,11 @@ export class AgGridColumnAdapter {
             }
             const minAlphaBound = gradientStyle.MinAlpha ?? DEFAULT_GRADIENT_MIN_ALPHA;
             const maxAlphaBound = gradientStyle.MaxAlpha ?? DEFAULT_GRADIENT_MAX_ALPHA;
-            const lo = Math.min(Helper.clamp(minAlphaBound, 0, 1), Helper.clamp(maxAlphaBound, 0, 1));
-            const hi = Math.max(Helper.clamp(minAlphaBound, 0, 1), Helper.clamp(maxAlphaBound, 0, 1));
+            const lo = Math.min(clamp(minAlphaBound, 0, 1), clamp(maxAlphaBound, 0, 1));
+            const hi = Math.max(clamp(minAlphaBound, 0, 1), clamp(maxAlphaBound, 0, 1));
             const span = Math.abs(max - min);
             let t = span === 0 ? 0.5 : (Number(colValue) - min) / span;
-            t = Helper.clamp(t, 0, 1);
+            t = clamp(t, 0, 1);
             if (reverseGradient) {
                 t = 1 - t;
             }
@@ -1448,11 +1442,12 @@ export class AgGridColumnAdapter {
                 const bg = tinycolor(preparedColor).setAlpha(alpha);
                 style.backgroundColor = bg.toRgbString();
                 if (gradientStyle.AutoContrastText) {
-                    style.color = bg.getLuminance() > 0.45 ? '#111111' : '#ffffff';
+                    style.color = getAutoContrastTextColor(preparedColor, alpha);
                 }
             }
         }
-        if (styledColumn.PercentBarStyle && styledColumn.PercentBarStyle.CellText) {
+        if (styledColumn.PercentBarStyle &&
+            hasBarStyleCellTextConfigured(styledColumn.PercentBarStyle.CellTextProperties)) {
             style.paddingTop = 0;
             style.paddingBottom = 0;
         }
@@ -1466,8 +1461,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 ??
@@ -1479,8 +1473,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 ??