@adaptabletools/adaptable 22.1.1-canary.1 → 23.0.0-canary.0

package/src/agGrid/AdaptableAgGrid.js

@@ -4,6 +4,7 @@ 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 Emitter from '../Utilities/Emitter';
 import { applyDefaultAdaptableOptions } from '../AdaptableOptions/DefaultAdaptableOptions';
 import { resolveContainerElement } from '../Utilities/resolveContainerElement';
@@ -45,7 +46,6 @@ import { FreeTextColumnModule } from '../Strategy/FreeTextColumnModule';
 import { LayoutModule } from '../Strategy/LayoutModule';
 import { PlusMinusModule } from '../Strategy/PlusMinusModule';
 import { QuickSearchModule } from '../Strategy/QuickSearchModule';
-import { ScheduleModule } from '../Strategy/ScheduleModule';
 import { SmartEditModule } from '../Strategy/SmartEditModule';
 import { ShortcutModule } from '../Strategy/ShortcutModule';
 import { StateManagementModule } from '../Strategy/StateManagementModule';
@@ -78,7 +78,10 @@ import { AgGridOptionsService } from './AgGridOptionsService';
 import { parseDateValue } from '../Utilities/Helpers/DateHelper';
 import { AgGridColumnAdapter } from './AgGridColumnAdapter';
 import getScrollbarSize from '../Utilities/getScrollbarSize';
-import { ONLY_AGG_FN_NAME, WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../AdaptableState/Common/AggregationColumns';
+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 { RowFormService } from '../Utilities/Services/RowFormService';
 import { FilterOnDataChangeOptions } from '../AdaptableState/Common/Enums';
 import { ADAPTABLE_PUBLISH_TIMESTAMP } from '../EnvVars';
@@ -88,7 +91,6 @@ 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';
@@ -108,6 +110,7 @@ import { clearPredicateDefMapMemo } from '../Api/Implementation/PredicateApiImpl
 import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AdaptableFilterHandler } from './AdaptableFilterHandler';
 import { AgGridFloatingFilterAdapterFactory } from './AgGridFloatingFilterAdapter';
+import { listenForDevTools } from '../setupDevTools';
 const LocalEventService_Prototype = LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -318,6 +321,7 @@ export class AdaptableAgGrid {
         }
         const doInit = (adaptableInstance) => {
             return adaptableInstance._initAdaptableAgGrid(config).then((api) => {
+                listenForDevTools(adaptableInstance);
                 if (Array.isArray(config.adaptableOptions.plugins)) {
                     config.adaptableOptions.plugins.forEach((plugin) => {
                         plugin.afterInit(adaptableInstance);
@@ -545,6 +549,9 @@ export class AdaptableAgGrid {
         if (quickSearchState.QuickSearchText) {
             this.setAgGridFindSearchValue(quickSearchState.QuickSearchText);
         }
+        else {
+            this.applyQuickSearchFindCssVars();
+        }
         this.addGridEventListeners();
         this.temporaryAdaptableStateUpdates();
         this.redrawBody();
@@ -704,6 +711,9 @@ export class AdaptableAgGrid {
             normalize: true,
         });
     }
+    getDefaultColumnWidthForCol(columnId) {
+        return this.layoutManager.getDefaultColumnWidthForCol(columnId);
+    }
     /**
      * Returns TRUE if filtering was applied, FALSE otherwise
      * This is important in the INIT phase because applying filtering will automatically refresh AG Grids columnState,
@@ -891,7 +901,16 @@ export class AdaptableAgGrid {
             // #customize_header
             const defaultColDef = { ...original_defaultColDef };
             defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
-                const columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(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 formattedHeaderName = this.api.formatColumnApi.internalApi.formatColumnHeaderName(columnHeaderName, params);
                 return formattedHeaderName;
             });
@@ -944,6 +963,9 @@ export class AdaptableAgGrid {
             // Use a getter to dynamically return different filter values based on Layout.RowGroupDisplayType
             Object.defineProperty(autoGroupColumnDef, 'filter', {
                 get: () => {
+                    if (this.isDestroyed) {
+                        return;
+                    }
                     const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
                     if (rowGroupDisplayType === 'single') {
                         return {
@@ -964,6 +986,9 @@ export class AdaptableAgGrid {
                 autoGroupColumnDef.suppressFloatingFilterButton = true;
                 Object.defineProperty(autoGroupColumnDef, 'floatingFilter', {
                     get: () => {
+                        if (this.isDestroyed) {
+                            return;
+                        }
                         const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
                         if (rowGroupDisplayType === 'single') {
                             return true;
@@ -986,6 +1011,9 @@ export class AdaptableAgGrid {
                 // Use a getter to dynamically return different floatingFilterComponent values based on Layout.RowGroupDisplayType
                 Object.defineProperty(autoGroupColumnDef, 'floatingFilterComponent', {
                     get: () => {
+                        if (this.isDestroyed) {
+                            return;
+                        }
                         const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
                         if (rowGroupDisplayType === 'single') {
                             return autoGroupFloatingFilterComponent;
@@ -1096,17 +1124,16 @@ export class AdaptableAgGrid {
             aggregationFunctions[ONLY_AGG_FN_NAME] = (params) => {
                 return only(params);
             };
-            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;
-            };
+            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);
+                };
+            });
             return aggregationFunctions;
         });
         /**
@@ -1916,7 +1943,6 @@ export class AdaptableAgGrid {
         modules.set(ModuleConstants.NoteModuleId, new NoteModule(this.api));
         modules.set(ModuleConstants.PlusMinusModuleId, new PlusMinusModule(this.api));
         modules.set(ModuleConstants.QuickSearchModuleId, new QuickSearchModule(this.api));
-        modules.set(ModuleConstants.ScheduleModuleId, new ScheduleModule(this.api));
         modules.set(ModuleConstants.SettingsPanelModuleId, new SettingsPanelModule(this.api));
         modules.set(ModuleConstants.ShortcutModuleId, new ShortcutModule(this.api));
         modules.set(ModuleConstants.SmartEditModuleId, new SmartEditModule(this.api));
@@ -2267,6 +2293,7 @@ export class AdaptableAgGrid {
         catch (ex) {
             this.logger.consoleError('AG Grid redrawRows failed to locate some row nodes.', rowNodes, ex);
         }
+        this.refreshAgGridFindIfNeeded();
     }
     refreshGridHeader() {
         this.agGridAdapter.getAgGridApi().refreshHeader();
@@ -2288,6 +2315,7 @@ export class AdaptableAgGrid {
     }
     refreshAllCells(forceUpdate) {
         this.agGridAdapter.getAgGridApi().refreshCells({ force: forceUpdate });
+        this.refreshAgGridFindIfNeeded();
     }
     refreshColumns(columns, forceUpdate, suppressFlash) {
         const refreshCellParams = {
@@ -3566,8 +3594,24 @@ export class AdaptableAgGrid {
             this.logger.consoleError('Find Search requires the AG Grid "FindModule". Please register this module to enable Find Search.');
             return;
         }
+        this.applyQuickSearchFindCssVars();
         this.agGridAdapter.setGridOption('findSearchValue', searchText);
     }
+    applyQuickSearchFindCssVars() {
+        applyQuickSearchFindCssVars(this.getAgGridContainerElement(), this.api.stateApi.getQuickSearchState());
+    }
+    refreshAgGridFind() {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('FindModule')) {
+            return;
+        }
+        this.agGridAdapter.getAgGridApi().findRefresh();
+    }
+    refreshAgGridFindIfNeeded() {
+        const quickSearchText = this.api.stateApi.getQuickSearchState()?.QuickSearchText;
+        if (!StringExtensions.IsNotNullOrEmpty(quickSearchText)) {
+            this.refreshAgGridFind();
+        }
+    }
     applyAdaptableTheme(theme) {
         const container = this.getAgGridContainerElement();
         if (container != null) {
@@ -3692,12 +3736,12 @@ export class AdaptableAgGrid {
     getAgGridColumnForColumnId(columnId) {
         return this.agGridAdapter.getAgGridApi().getColumn(columnId);
     }
-    getMinMaxCachedValueForColumn(column, minMax) {
+    getMinMaxCachedValueForColumn(column, aggregation) {
         const { columnId, dataType } = column;
         if (dataType !== 'number') {
             return undefined;
         }
-        let value = this.columnMinMaxValuesCache[columnId]?.[minMax];
+        let value = this.columnMinMaxValuesCache[columnId]?.[aggregation];
         if (value !== undefined) {
             return value;
         }
@@ -3708,10 +3752,25 @@ export class AdaptableAgGrid {
         if (distinctRawValues.length === 0) {
             return undefined;
         }
-        value = minMax === 'min' ? Math.min(...distinctRawValues) : Math.max(...distinctRawValues);
+        if (aggregation === 'min') {
+            value = Math.min(...distinctRawValues);
+        }
+        else if (aggregation === 'max') {
+            value = Math.max(...distinctRawValues);
+        }
+        else if (aggregation === 'avg') {
+            const sum = distinctRawValues.reduce((acc, v) => acc + v, 0);
+            value = sum / distinctRawValues.length;
+        }
+        else {
+            // median - sort a shallow copy so we don't mutate the source
+            const sorted = [...distinctRawValues].sort((a, b) => a - b);
+            const mid = Math.floor(sorted.length / 2);
+            value = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+        }
         this.columnMinMaxValuesCache[columnId] = {
             ...this.columnMinMaxValuesCache[columnId],
-            [minMax]: value,
+            [aggregation]: value,
         };
         return value;
     }
@@ -3990,25 +4049,6 @@ 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/AdaptableLogger.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
 export declare const errorOnce: (message: string) => void;
+export declare const warnOnce: (message: string) => void;
 /**
  * AdapTable's Logger
  */

package/src/agGrid/AdaptableLogger.js

@@ -4,6 +4,7 @@ const performanceTime = (previousTime) => {
     return Math.round(previousTime ? now - previousTime : now);
 };
 const errorOnceFlags = {};
+const warnOnceFlags = {};
 export const errorOnce = (message) => {
     if (errorOnceFlags[message]) {
         return;
@@ -11,6 +12,13 @@ export const errorOnce = (message) => {
     console.error(message);
     errorOnceFlags[message] = true;
 };
+export const warnOnce = (message) => {
+    if (warnOnceFlags[message]) {
+        return;
+    }
+    console.warn(message);
+    warnOnceFlags[message] = true;
+};
 /**
  * AdapTable's Logger
  */

package/src/agGrid/AgGridAdapter.d.ts

@@ -57,6 +57,7 @@ export declare class AgGridAdapter {
     private isColumnRowGroupable;
     private isColumnPivotable;
     private isColumnAggregetable;
+    private getUserAllowedAggFuncs;
     private getColumnAggregationFunctions;
     private isTreeColumn;
     private isColumnMoveable;

package/src/agGrid/AgGridAdapter.js

@@ -8,7 +8,8 @@ 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 { isWeightedAverageAggFuncName } from '../AdaptableState/Common/AggregationColumns';
+import { getParameterizedAggregationDefinitionByAgGridName } from '../Aggregation/ParameterizedAggregationRegistry';
+import { isParameterizedAggFuncName } from '../Aggregation/ParameterizedAggregationRegistry';
 // 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;
@@ -225,8 +226,9 @@ export class AgGridAdapter {
             if (fctName === 'only') {
                 return 'Only';
             }
-            if (fctName === 'weightedAvg') {
-                return 'Weighted Average';
+            const parameterizedDefinition = getParameterizedAggregationDefinitionByAgGridName(fctName);
+            if (parameterizedDefinition) {
+                return parameterizedDefinition.agGridAggFuncName;
             }
             return original_getDefaultFuncLabel.call(this, fctName);
         };
@@ -540,6 +542,10 @@ 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;
+            }
             if (typeof colDef.aggFunc === 'string') {
                 abColumn.aggregationFunction = colDef.aggFunc;
             }
@@ -678,6 +684,12 @@ 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);
@@ -687,7 +699,7 @@ export class AgGridAdapter {
         if (!hasAllowedAggFuncs) {
             result.push(...gridOptionsAggFuncNames);
         }
-        result = result.filter((func) => !isWeightedAverageAggFuncName(func));
+        result = result.filter((func) => !isParameterizedAggFuncName(func));
         return [...new Set(result)];
     }
     isTreeColumn(isGeneratedRowGroupColumn) {

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -25,11 +25,20 @@ export declare class AgGridColumnAdapter {
     private setupColumnValueGetter;
     private setupColumnCellClass;
     private setupColumnHeaderClass;
+    private quickSearchStyleToDynamicCssVars;
     private setupColumnCellStyle;
     private setupColumnHeaderStyle;
     private setupColumnCellEditor;
     private setupColumnCellRenderer;
     private setupColumnTooltipValueGetter;
+    /**
+     * Resolves a Range Bar bound (number / column id / Col-Min / Col-Max /
+     * Col-Avg / Col-Median) into a concrete numeric value for the supplied row.
+     * Mirrors the resolution logic in `RangeBarRenderer.resolveBoundValue` and
+     * is used by the tooltip path. Returns `undefined` when the bound cannot
+     * be resolved (e.g. unknown column id or non-numeric source value).
+     */
+    private resolveRangeBarBound;
     private setupColumnQuickFilterText;
     private setupColumnAllowedAggFuncs;
     private setupColumnType;
@@ -64,6 +73,23 @@ export declare class AgGridColumnAdapter {
      * This function decides when the two can be merged.
      */
     private getFormatColumnAndStyledColumnCellStyle;
+    /**
+     * Returns true when the active Styled Column declares a `Font` slot
+     * (and therefore claims all Font-slice properties on this column).
+     *
+     * Note: Badge claims **only** `Alignment` from the Font slice — pill
+     * typography is owned per-pill via `PillStyle`, never inherited from a
+     * Format Column. Stripping the whole Font slice when Badge declares
+     * `Alignment` keeps the precedence rule simple and is fine in practice
+     * because Format-Column-derived font styles don't apply to flex rows of
+     * pills anyway.
+     */
+    private styledColumnClaimsFontStyle;
+    /**
+     * Returns true when the active Styled Column declares a `Cell` slot
+     * (and therefore claims all Cell-slice properties on this column).
+     */
+    private styledColumnClaimsCellBoxStyle;
     private getFormatColumnHeaderStyle;
     private getStyledColumnStyle;
     private getFormatColumnCellStyle;