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

package/src/agGrid/AdaptableAgGrid.js

@@ -8,6 +8,7 @@ const ag_grid_enterprise_1 = require("ag-grid-enterprise");
 const AdaptableLogger_1 = require("./AdaptableLogger");
 const DocumentationLinkConstants_1 = require("../Utilities/Constants/DocumentationLinkConstants");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensions/StringExtensions"));
+const QuickSearchStyleHelper_1 = require("../Utilities/Helpers/QuickSearchStyleHelper");
 const Emitter_1 = tslib_1.__importDefault(require("../Utilities/Emitter"));
 const DefaultAdaptableOptions_1 = require("../AdaptableOptions/DefaultAdaptableOptions");
 const resolveContainerElement_1 = require("../Utilities/resolveContainerElement");
@@ -49,7 +50,6 @@ const FreeTextColumnModule_1 = require("../Strategy/FreeTextColumnModule");
 const LayoutModule_1 = require("../Strategy/LayoutModule");
 const PlusMinusModule_1 = require("../Strategy/PlusMinusModule");
 const QuickSearchModule_1 = require("../Strategy/QuickSearchModule");
-const ScheduleModule_1 = require("../Strategy/ScheduleModule");
 const SmartEditModule_1 = require("../Strategy/SmartEditModule");
 const ShortcutModule_1 = require("../Strategy/ShortcutModule");
 const StateManagementModule_1 = require("../Strategy/StateManagementModule");
@@ -83,6 +83,9 @@ const DateHelper_1 = require("../Utilities/Helpers/DateHelper");
 const AgGridColumnAdapter_1 = require("./AgGridColumnAdapter");
 const getScrollbarSize_1 = tslib_1.__importDefault(require("../Utilities/getScrollbarSize"));
 const AggregationColumns_1 = require("../AdaptableState/Common/AggregationColumns");
+const ParameterizedAggregationRegistry_1 = require("../Aggregation/ParameterizedAggregationRegistry");
+const parameterizedAggregationHelpers_1 = require("../Aggregation/parameterizedAggregationHelpers");
+const parameterizedAggregationHeader_1 = require("../Aggregation/parameterizedAggregationHeader");
 const RowFormService_1 = require("../Utilities/Services/RowFormService");
 const Enums_1 = require("../AdaptableState/Common/Enums");
 const EnvVars_1 = require("../EnvVars");
@@ -92,7 +95,6 @@ const AdaptableLoadingScreen_1 = require("../View/Components/Popups/AdaptableLoa
 const react_1 = require("react");
 const createAgStatusPanelComponent_1 = require("../Utilities/createAgStatusPanelComponent");
 const only_1 = require("../Utilities/only");
-const weightedAverage_1 = require("../Utilities/weightedAverage");
 const RowSummary_1 = require("../AdaptableState/Common/RowSummary");
 const FlashingCellService_1 = require("../Utilities/Services/FlashingCellService");
 const AgGridExportAdapter_1 = require("./AgGridExportAdapter");
@@ -112,6 +114,7 @@ const PredicateApiImpl_1 = require("../Api/Implementation/PredicateApiImpl");
 const AgGridFilterAdapter_1 = require("./AgGridFilterAdapter");
 const AdaptableFilterHandler_1 = require("./AdaptableFilterHandler");
 const AgGridFloatingFilterAdapter_1 = require("./AgGridFloatingFilterAdapter");
+const setupDevTools_1 = require("../setupDevTools");
 const LocalEventService_Prototype = ag_grid_enterprise_1.LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -322,6 +325,7 @@ class AdaptableAgGrid {
         }
         const doInit = (adaptableInstance) => {
             return adaptableInstance._initAdaptableAgGrid(config).then((api) => {
+                (0, setupDevTools_1.listenForDevTools)(adaptableInstance);
                 if (Array.isArray(config.adaptableOptions.plugins)) {
                     config.adaptableOptions.plugins.forEach((plugin) => {
                         plugin.afterInit(adaptableInstance);
@@ -549,6 +553,9 @@ class AdaptableAgGrid {
         if (quickSearchState.QuickSearchText) {
             this.setAgGridFindSearchValue(quickSearchState.QuickSearchText);
         }
+        else {
+            this.applyQuickSearchFindCssVars();
+        }
         this.addGridEventListeners();
         this.temporaryAdaptableStateUpdates();
         this.redrawBody();
@@ -708,6 +715,9 @@ 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,
@@ -895,7 +905,16 @@ class AdaptableAgGrid {
             // #customize_header
             const defaultColDef = { ...original_defaultColDef };
             defaultColDef.headerValueGetter = (0, adaptableOverrideCheck_1.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 = (0, parameterizedAggregationHeader_1.getParameterizedAggregationHeaderParenthesisValue)(this.api, params.column.getColId(), currentLayout);
+                    if (parameterizedParenthesisValue) {
+                        columnHeaderName = parameterizedParenthesisValue;
+                    }
+                }
                 const formattedHeaderName = this.api.formatColumnApi.internalApi.formatColumnHeaderName(columnHeaderName, params);
                 return formattedHeaderName;
             });
@@ -948,6 +967,9 @@ 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 {
@@ -968,6 +990,9 @@ 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;
@@ -990,6 +1015,9 @@ 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;
@@ -1100,17 +1128,16 @@ class AdaptableAgGrid {
             aggregationFunctions[AggregationColumns_1.ONLY_AGG_FN_NAME] = (params) => {
                 return (0, only_1.only)(params);
             };
-            aggregationFunctions[AggregationColumns_1.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 (0, weightedAverage_1.weightedAverage)(params, params.colDef.colId, adaptableAggFunc.weightedColumnId);
-                }
-                return undefined;
-            };
+            (0, ParameterizedAggregationRegistry_1.getParameterizedAggregationDefinitions)().forEach((definition) => {
+                aggregationFunctions[definition.agGridAggFuncName] = (params) => {
+                    const columnId = params.column.getColId();
+                    const parameterizedAggFunc = (0, parameterizedAggregationHelpers_1.getParameterizedAggForColumn)(columnId, this.api.layoutApi.getCurrentLayout());
+                    if (!parameterizedAggFunc || parameterizedAggFunc.type !== definition.type) {
+                        return undefined;
+                    }
+                    return (0, ParameterizedAggregationRegistry_1.computeParameterizedAggregation)(params, params.colDef.colId, parameterizedAggFunc);
+                };
+            });
             return aggregationFunctions;
         });
         /**
@@ -1426,7 +1453,7 @@ class AdaptableAgGrid {
                 // dataType: 'Number',
                 // AG Grid requires either dataType or numberFormat to be set for Numbers
                 numberFormat: {
-                    format: `#,##0.00`,
+                    format: '0.###############',
                 },
             });
             // store original excel styles, we will have to revert to them after each VISUAL EXPORT
@@ -1920,7 +1947,6 @@ class AdaptableAgGrid {
         modules.set(ModuleConstants.NoteModuleId, new NoteModule_1.NoteModule(this.api));
         modules.set(ModuleConstants.PlusMinusModuleId, new PlusMinusModule_1.PlusMinusModule(this.api));
         modules.set(ModuleConstants.QuickSearchModuleId, new QuickSearchModule_1.QuickSearchModule(this.api));
-        modules.set(ModuleConstants.ScheduleModuleId, new ScheduleModule_1.ScheduleModule(this.api));
         modules.set(ModuleConstants.SettingsPanelModuleId, new SettingsPanelModule_1.SettingsPanelModule(this.api));
         modules.set(ModuleConstants.ShortcutModuleId, new ShortcutModule_1.ShortcutModule(this.api));
         modules.set(ModuleConstants.SmartEditModuleId, new SmartEditModule_1.SmartEditModule(this.api));
@@ -2271,6 +2297,7 @@ 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();
@@ -2292,6 +2319,7 @@ class AdaptableAgGrid {
     }
     refreshAllCells(forceUpdate) {
         this.agGridAdapter.getAgGridApi().refreshCells({ force: forceUpdate });
+        this.refreshAgGridFindIfNeeded();
     }
     refreshColumns(columns, forceUpdate, suppressFlash) {
         const refreshCellParams = {
@@ -3570,8 +3598,24 @@ 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() {
+        (0, QuickSearchStyleHelper_1.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_1.default.IsNotNullOrEmpty(quickSearchText)) {
+            this.refreshAgGridFind();
+        }
+    }
     applyAdaptableTheme(theme) {
         const container = this.getAgGridContainerElement();
         if (container != null) {
@@ -3696,12 +3740,12 @@ 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;
         }
@@ -3712,10 +3756,25 @@ 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;
     }
@@ -3994,25 +4053,6 @@ class AdaptableAgGrid {
             ],
         });
     }
-    getActiveAdaptableAggFuncForCol(columnId) {
-        if (!columnId) {
-            return null;
-        }
-        const currentLayout = this.api.layoutApi.getCurrentLayout();
-        const aggregationFunctionsColumnsMap = ((0, LayoutHelpers_1.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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableLogger = exports.errorOnce = void 0;
+exports.AdaptableLogger = exports.warnOnce = exports.errorOnce = void 0;
 const infinite_react_1 = require("@infinite-table/infinite-react");
 const performanceTime = (previousTime) => {
     const now = performance.now();
     return Math.round(previousTime ? now - previousTime : now);
 };
 const errorOnceFlags = {};
+const warnOnceFlags = {};
 const errorOnce = (message) => {
     if (errorOnceFlags[message]) {
         return;
@@ -15,6 +16,14 @@ const errorOnce = (message) => {
     errorOnceFlags[message] = true;
 };
 exports.errorOnce = errorOnce;
+const warnOnce = (message) => {
+    if (warnOnceFlags[message]) {
+        return;
+    }
+    console.warn(message);
+    warnOnceFlags[message] = true;
+};
+exports.warnOnce = warnOnce;
 /**
  * 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

@@ -12,7 +12,8 @@ const agGridDataTypeDefinitions_1 = require("./agGridDataTypeDefinitions");
 const ColumnApiImpl_1 = require("../Api/Implementation/ColumnApiImpl");
 const isPivotColumnTotal_1 = require("../layout-manager/src/isPivotColumnTotal");
 const isPivotAggTotalColumn_1 = require("../layout-manager/src/isPivotAggTotalColumn");
-const AggregationColumns_1 = require("../AdaptableState/Common/AggregationColumns");
+const ParameterizedAggregationRegistry_1 = require("../Aggregation/ParameterizedAggregationRegistry");
+const ParameterizedAggregationRegistry_2 = require("../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 = () => ag_grid_enterprise_1.ColumnApiModule;
@@ -229,8 +230,9 @@ class AgGridAdapter {
             if (fctName === 'only') {
                 return 'Only';
             }
-            if (fctName === 'weightedAvg') {
-                return 'Weighted Average';
+            const parameterizedDefinition = (0, ParameterizedAggregationRegistry_1.getParameterizedAggregationDefinitionByAgGridName)(fctName);
+            if (parameterizedDefinition) {
+                return parameterizedDefinition.agGridAggFuncName;
             }
             return original_getDefaultFuncLabel.call(this, fctName);
         };
@@ -544,6 +546,10 @@ 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;
             }
@@ -682,6 +688,12 @@ 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);
@@ -691,7 +703,7 @@ class AgGridAdapter {
         if (!hasAllowedAggFuncs) {
             result.push(...gridOptionsAggFuncNames);
         }
-        result = result.filter((func) => !(0, AggregationColumns_1.isWeightedAverageAggFuncName)(func));
+        result = result.filter((func) => !(0, ParameterizedAggregationRegistry_2.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;