@adaptabletools/adaptable 20.0.5 → 20.0.7-canary.0

package/src/Api/Internal/ColumnInternalApi.d.ts

@@ -1,5 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
-import { Column, IRowNode } from 'ag-grid-enterprise';
+import { Column, HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
 import { CustomSort } from '../../AdaptableState/CustomSortState';
 import { ColumnValuesComparer } from '../../AdaptableOptions/CustomSortOptions';
 import { AdaptableColumn } from '../../types';
@@ -31,4 +31,6 @@ export declare class ColumnInternalApi extends ApiBase {
     getAgGridColumnForAdaptableColumn(columnId: string): Column;
     getActiveColumnComparator(columnId: string, customSort?: CustomSort, customSortComparer?: ColumnValuesComparer): (valueA: any, valueB: any, nodeA?: IRowNode, nodeB?: IRowNode, isInverted?: boolean) => number | undefined;
     isSpecialColumn(columnId: string, column?: AdaptableColumn): boolean;
+    getColumnHeaderName(params: HeaderValueGetterParams): string;
+    private buildColumnHeaderContext;
 }

package/src/Api/Internal/ColumnInternalApi.js

@@ -2,6 +2,10 @@ import { ApiBase } from '../Implementation/ApiBase';
 import { AG_GRID_GROUPED_COLUMN } from '../../Utilities/Constants/GeneralConstants';
 import uniq from 'lodash/uniq';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
+import { isPivotGrandTotalColumn, isPivotResultColumn } from '../Implementation/ColumnApiImpl';
+import { destructurePivotColumnId } from '../../layout-manager/src/destructurePivotColumnId';
+import { isPivotGroupTotalColumn } from '../../layout-manager/src/isPivotGroupTotalColumn';
+import { isPivotTotalColumn } from '../../layout-manager/src/isPivotTotalColumn';
 export function getAutoRowGroupColumnIdFor(columnId) {
     return `${AG_GRID_GROUPED_COLUMN}-${columnId}`;
 }
@@ -81,4 +85,201 @@ export class ColumnInternalApi extends ApiBase {
                 this.getColumnApi().isActionColumn(columnId) ||
                 this.getColumnApi().isFdc3Column(columnId));
     }
+    getColumnHeaderName(params) {
+        // this is the same object, but casting it makes it easier to work with
+        const isColumn = !params.columnGroup;
+        const columnParams = params;
+        const isColumnGroup = !!params.columnGroup;
+        const columnGroupParams = params;
+        const defaultHeaderName = params.colDef?.headerName ??
+            (isColumn ? StringExtensions.CamelCaseToHumanText(columnParams.colDef?.field) : '') ??
+            '';
+        // for now we override ONLY the header names
+        if (params.location !== 'header') {
+            return defaultHeaderName;
+        }
+        // 1. Layout specific header has the highest priority
+        const layoutSpecificCustomHeader = this.getLayoutApi().getCurrentLayout().ColumnHeaders?.[isColumn ? columnParams.column.getColId() : columnGroupParams.columnGroup.getGroupId()];
+        if (layoutSpecificCustomHeader) {
+            return layoutSpecificCustomHeader;
+        }
+        // 2. check for custom ColumnOptions.columnHeader
+        if (typeof this.getColumnOptions().columnHeader === 'function') {
+            const columnHeaderContext = this.buildColumnHeaderContext(params, defaultHeaderName);
+            if (columnHeaderContext === 'skip') {
+                return defaultHeaderName;
+            }
+            const customHeader = this.getColumnOptions().columnHeader(columnHeaderContext);
+            return customHeader;
+        }
+        // 3. fallback to default header name
+        return defaultHeaderName;
+    }
+    buildColumnHeaderContext(params, defaultHeaderName) {
+        const currentLayoutType = this.getLayoutApi().isCurrentLayoutPivot() ? 'pivot' : 'table';
+        const currentLayout = this.getLayoutApi().getCurrentLayout();
+        const baseContext = {
+            ...this.getAdaptableApi().internalApi.buildBaseContext(),
+            defaultHeaderName,
+            currentLayout,
+            currentLayoutName: currentLayout.Name,
+            currentLayoutType: currentLayoutType,
+        };
+        // makes it easier to work with
+        const currentTableLayout = currentLayout;
+        const currentPivotLayout = currentLayout;
+        if (params.column?.getColId() === AG_GRID_GROUPED_COLUMN) {
+            const columnType = 'autoGroupColumn';
+            return {
+                ...baseContext,
+                columnType,
+                columnId: params.column.getColId(),
+                groupedColumnIds: currentLayoutType === 'table'
+                    ? currentTableLayout.RowGroupedColumns ?? []
+                    : currentPivotLayout.PivotGroupedColumns ?? [],
+            };
+        }
+        if (params.column?.getColId().startsWith(`${AG_GRID_GROUPED_COLUMN}-`)) {
+            const columnType = 'groupColumn';
+            const columnId = params.column.getColId();
+            // remove `${AG_GRID_GROUPED_COLUMN}-` from beginning of columnId
+            const groupColumnId = columnId.substring(`${AG_GRID_GROUPED_COLUMN}-`.length);
+            return {
+                ...baseContext,
+                columnType,
+                columnId,
+                groupColumnId,
+            };
+        }
+        if (baseContext.currentLayoutType === 'table') {
+            if (params.columnGroup) {
+                const columnType = 'tableColumnGroup';
+                if (!params.colDef?.children) {
+                    // AG Grid created virtual column groups for all columns
+                    // we want to skip those
+                    return 'skip';
+                }
+                return {
+                    ...baseContext,
+                    columnType,
+                    groupId: params.columnGroup?.getGroupId(),
+                    childrenColumnIds: params.columnGroup
+                        ?.getChildren()
+                        .map((col) => {
+                        if (col.isColumn) {
+                            return col.getColId();
+                        }
+                    })
+                        .filter(Boolean),
+                    state: params.columnGroup?.isExpandable() && !params.columnGroup?.isExpanded()
+                        ? 'collapsed'
+                        : 'expanded',
+                };
+            }
+            if (params.column) {
+                const columnType = 'tableColumn';
+                return {
+                    ...baseContext,
+                    columnType,
+                    columnId: params.column?.getColId(),
+                    aggregation: params.column.getAggFunc(),
+                };
+            }
+        }
+        if (baseContext.currentLayoutType === 'pivot') {
+            if (params.columnGroup) {
+                if (!params.colDef?.pivotKeys) {
+                    // we might have user defined colGroups, but we are not interested in them in pivot mode
+                    return 'skip';
+                }
+                const columnType = 'pivotColumnGroup';
+                return {
+                    ...baseContext,
+                    columnType,
+                    groupId: params.columnGroup?.getGroupId(),
+                    pivotKeys: params.colDef.pivotKeys,
+                    state: params.columnGroup?.isExpandable() && !params.columnGroup?.isExpanded()
+                        ? 'collapsed'
+                        : 'expanded',
+                };
+            }
+            if (params.column) {
+                let columnId = params.column.getColId();
+                if (isPivotGrandTotalColumn(columnId)) {
+                    const columnType = 'pivotGrandTotal';
+                    const pivotValueCol = params.colDef.pivotValueColumn;
+                    const aggregatedColumnId = pivotValueCol?.getColId();
+                    const currentLayoutAggCols = currentPivotLayout.PivotAggregationColumns?.map((col) => col.ColumnId);
+                    if (!currentLayoutAggCols?.includes(aggregatedColumnId)) {
+                        // this column is not an aggregation column
+                        return 'skip';
+                    }
+                    return {
+                        ...baseContext,
+                        columnType,
+                        aggregatedColumnId,
+                        aggregation: pivotValueCol.getAggFunc(),
+                    };
+                }
+                if (isPivotGroupTotalColumn(params.colDef)) {
+                    const columnType = 'pivotGroupTotal';
+                    const pivotColInfo = destructurePivotColumnId(params.colDef, {
+                        pivotColIds: currentPivotLayout.PivotColumns,
+                        aggColIds: currentPivotLayout.PivotAggregationColumns.map((col) => col.ColumnId),
+                    }, (message) => this.logWarn(message));
+                    if (pivotColInfo === '!unknown!') {
+                        return 'skip';
+                    }
+                    const pivotKey = pivotColInfo.pivotKeys[pivotColInfo.pivotKeys.length - 1];
+                    return {
+                        ...baseContext,
+                        columnType,
+                        pivotKey,
+                        pivotColumnId: pivotColInfo.pivotColumnId,
+                        aggregation: params.colDef?.pivotValueColumn?.getAggFunc(),
+                    };
+                }
+                if (isPivotTotalColumn(params.colDef)) {
+                    const columnType = 'pivotAggregationTotal';
+                    const pivotValueCol = params.colDef.pivotValueColumn;
+                    const pivotColInfo = destructurePivotColumnId(params.colDef, {
+                        pivotColIds: currentPivotLayout.PivotColumns,
+                        aggColIds: currentPivotLayout.PivotAggregationColumns.map((col) => col.ColumnId),
+                    }, (message) => this.logWarn(message));
+                    if (pivotColInfo === '!unknown!') {
+                        return 'skip';
+                    }
+                    const pivotKey = pivotColInfo.pivotKeys[pivotColInfo.pivotKeys.length - 1];
+                    return {
+                        ...baseContext,
+                        columnType,
+                        aggregatedColumnId: pivotValueCol?.getColId(),
+                        aggregation: pivotValueCol.getAggFunc(),
+                        pivotColumnId: pivotColInfo.pivotColumnId,
+                        pivotKey,
+                    };
+                }
+                if (isPivotResultColumn(columnId)) {
+                    const columnType = 'pivotAggregationColumn';
+                    const pivotValueCol = params.colDef.pivotValueColumn;
+                    const aggregatedColumnId = pivotValueCol?.getColId();
+                    const currentLayoutAggCols = currentPivotLayout.PivotAggregationColumns?.map((col) => col.ColumnId);
+                    if (!currentLayoutAggCols?.includes(aggregatedColumnId)) {
+                        // this column is not an aggregation column
+                        return 'skip';
+                    }
+                    return {
+                        ...baseContext,
+                        columnType,
+                        columnId,
+                        pivotKeys: params.colDef.pivotKeys,
+                        aggregatedColumnId,
+                        aggregation: pivotValueCol.getAggFunc(),
+                    };
+                }
+            }
+        }
+        // if nothing matched, we skip this column[group]
+        return 'skip';
+    }
 }

package/src/Utilities/Constants/GeneralConstants.d.ts

@@ -24,6 +24,7 @@ export declare const GROUP_PATH_SEPARATOR: string;
 export declare const AG_GRID_GROUPED_COLUMN: string;
 export declare const AG_GRID_SELECTION_COLUMN: string;
 export declare const AG_GRID_PIVOT_COLUMN: string;
+export declare const AG_GRID_PIVOT_GRAND_TOTAL_COLUMN: string;
 export declare const AG_GRID_CHART_WINDOW = "AG Grid Window";
 export declare const ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME = "(FDC3ActionColumn)";
 export declare const DEFAULT_DATE_FORMAT_PATTERN = "dd-MM-yyyy";

package/src/Utilities/Constants/GeneralConstants.js

@@ -23,6 +23,7 @@ export const GROUP_PATH_SEPARATOR = '/';
 export const AG_GRID_GROUPED_COLUMN = 'ag-Grid-AutoColumn';
 export const AG_GRID_SELECTION_COLUMN = 'ag-Grid-SelectionColumn';
 export const AG_GRID_PIVOT_COLUMN = 'pivot_';
+export const AG_GRID_PIVOT_GRAND_TOTAL_COLUMN = 'PivotRowTotal_pivot_';
 export const AG_GRID_CHART_WINDOW = 'AG Grid Window';
 export const ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME = '(FDC3ActionColumn)';
 // FIXME AFL - load this from DateInputOptions

package/src/Utilities/Extensions/StringExtensions.js

@@ -23,13 +23,21 @@ export function IsNullOrEmptyOrWhiteSpace(stringToCheck) {
 export function IsNotNullOrEmptyOrWhiteSpace(stringToCheck) {
     return !IsNullOrEmptyOrWhiteSpace(stringToCheck);
 }
-// from https://stackoverflow.com/questions/15369566/putting-space-in-camel-case-string-using-regular-expression
+// clone of A Grid's implementation
+// https://github.com/ag-grid/ag-grid/blob/a5c3d9f56350271ab7e8d42d72aaf5314672719a/packages/ag-grid-community/src/columns/columnNameService.ts#L14
 export function CamelCaseToHumanText(camelCase) {
     if (!camelCase || camelCase == null) {
         return null;
     }
-    const rex = /([A-Z])([A-Z])([a-z])|([a-z])([A-Z])/g;
-    const words = camelCase.replace(rex, '$1$4 $2$3$5').replace('.', ' ').split(' ');
+    // either split on a lowercase followed by uppercase ie  asHereTo -> as Here To
+    const rex = /([a-z])([A-Z])/g;
+    // or starts with uppercase and we take all expect the last which is assumed to be part of next word if followed by lowercase HEREToThere -> HERE To There
+    const rexCaps = /([A-Z]+)([A-Z])([a-z])/g;
+    const words = camelCase
+        .replace(rex, '$1 $2')
+        .replace(rexCaps, '$1 $2$3')
+        .replace(/\./g, ' ')
+        .split(' ');
     return words
         .map((word) => word.substring(0, 1).toUpperCase() + (word.length > 1 ? word.substring(1, word.length) : ''))
         .join(' ');

package/src/Utilities/adaptableOverrideCheck.d.ts

@@ -0,0 +1,2 @@
+export declare function tagProvidedByAdaptable(fn: any): any;
+export declare function isProvidedByAdaptable(fn: any): boolean;

package/src/Utilities/adaptableOverrideCheck.js

@@ -0,0 +1,8 @@
+const PROVIDED_BY_ADAPTABLE = Symbol('isProvidedByAdaptable');
+export function tagProvidedByAdaptable(fn) {
+    fn[PROVIDED_BY_ADAPTABLE] = true;
+    return fn;
+}
+export function isProvidedByAdaptable(fn) {
+    return fn && !!fn[PROVIDED_BY_ADAPTABLE];
+}

package/src/agGrid/AdaptableAgGrid.js

@@ -97,6 +97,7 @@ import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT
 import { agGridDataTypeDefinitions } from './agGridDataTypeDefinitions';
 import { AgGridThemeAdapter } from './AgGridThemeAdapter';
 import { mapOldTypeToDataType } from '../migration/VersionUpgrade20';
+import { tagProvidedByAdaptable } from '../Utilities/adaptableOverrideCheck';
 const LocalEventService_Prototype = LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -610,6 +611,34 @@ You need to define at least one Layout!`);
             this.agGridAdapter.setAgGridId(agGridId);
             return agGridId;
         });
+        /**
+         * `defaultColDef`
+         */
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'defaultColDef', (original_defaultColDef) => {
+            if (original_defaultColDef?.headerValueGetter) {
+                this.logger.warn(`defaultColDef.headerValueGetter and overrides the Adaptable custom header mechanism! We recommend using a ColumnOptions.tableColumnHeader instead!`);
+                return original_defaultColDef;
+            }
+            const defaultColDef = original_defaultColDef ?? {};
+            defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
+                return this.api.columnApi.internalApi.getColumnHeaderName(params);
+            });
+            return defaultColDef;
+        });
+        /**
+         * `defaultColGroupDef`
+         */
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'defaultColGroupDef', (original_defaultColGroupDef) => {
+            if (original_defaultColGroupDef?.headerValueGetter) {
+                this.logger.warn(`defaultColGroupDef.headerValueGetter and overrides the Adaptable custom header mechanism! We recommend using a ColumnOptions.tableColumnHeader instead!`);
+                return original_defaultColGroupDef;
+            }
+            const defaultColGroupDef = original_defaultColGroupDef ?? {};
+            defaultColGroupDef.headerValueGetter = tagProvidedByAdaptable((params) => {
+                return this.api.columnApi.internalApi.getColumnHeaderName(params);
+            });
+            return defaultColGroupDef;
+        });
         /**
          * `theme`
          */

package/src/agGrid/AgGridAdapter.js

@@ -374,6 +374,7 @@ export class AgGridAdapter {
                     agColumn: agGridColumn,
                     columnGroup: isRealColumnGroup ? ColumnGroup : undefined,
                     displayName: displayName,
+                    ...this.adaptableApi.internalApi.buildBaseContext(),
                 })
                 : null;
             friendlyName =

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -27,7 +27,7 @@ export declare class AgGridColumnAdapter {
     private setupColumnAllowedAggFuncs;
     private setupColumnType;
     private setupColumnCellDataType;
-    setupColumnHeader({ col, abColumn }: ColumnSetupInfo): boolean;
+    setupColumnHeader({ col, abColumn }: ColumnSetupInfo): void;
     private setupColumnFilter;
     setupColumnFloatingFilterTemporarily(initialGridOptions: GridOptions): void;
     private setupColumnFloatingFilter;

package/src/agGrid/AgGridColumnAdapter.js

@@ -12,7 +12,8 @@ import Helper from '../Utilities/Helpers/Helper';
 import { AdaptableNumberEditor, AdaptableReactNumberEditor } from './editors/AdaptableNumberEditor';
 import { AdaptableDateEditor, AdaptableReactDateEditor } from './editors/AdaptableDateEditor';
 import { AgGridExportAdapter } from './AgGridExportAdapter';
-import { AdaptableHelper, } from '../Utilities/Helpers/AdaptableHelper';
+import { AdaptableHelper } from '../Utilities/Helpers/AdaptableHelper';
+import { isProvidedByAdaptable } from '../Utilities/adaptableOverrideCheck';
 export function getEditorForColumnDataType(columnDataType, variant) {
     if (columnDataType === 'number') {
         return variant === 'react' ? AdaptableReactNumberEditor : AdaptableNumberEditor;
@@ -371,19 +372,12 @@ export class AgGridColumnAdapter {
         });
     }
     setupColumnHeader({ col, abColumn }) {
-        const previousColumnHeader = col?.getColDef()?.headerName;
-        this.setColDefProperty(col, 'headerName', (userHeaderName) => {
-            // set the default to the AG Grid provided values
-            // from https://github.com/ag-grid/ag-grid/blob/v26.1.0/community-modules/core/src/ts/columns/columnModel.ts#L2515
-            let resultHeaderName = userHeaderName ?? StringExtensions.CamelCaseToHumanText(col.getColDef().field);
-            const layoutCustomHeader = this.adaptableApi.layoutApi.getCurrentLayout().ColumnHeaders?.[col.getColId()];
-            if (layoutCustomHeader) {
-                resultHeaderName = layoutCustomHeader;
-            }
-            return resultHeaderName;
+        this.setColDefProperty(col, 'headerValueGetter', (original_headerValueGetter) => {
+            if (!isProvidedByAdaptable(original_headerValueGetter)) {
+                this.adaptableApi.logWarn(`colDef.headerValueGetter is defined for column '${col.getColId()}', and overrides the Adaptable custom header mechanism! We recommend using a ColumnOptions.tableColumnHeader instead!`);
+            }
+            return original_headerValueGetter;
         });
-        const newColumnHeader = col?.getColDef()?.headerName;
-        return previousColumnHeader !== newColumnHeader;
     }
     setupColumnFilter({ col, colDef }) {
         this.setColDefProperty(col, 'filter', () => {

package/src/components/Select/Select.js

@@ -29,7 +29,7 @@ const INFINITE_COLUMNS_WITH_CHECKBOX = {
         resizable: false,
         defaultSortable: false,
         renderSelectionCheckBox: ({ renderBag }) => {
-            return (React.createElement(Box, { display: 'inline-block', style: checkboxStyle }, renderBag.selectionCheckBox));
+            return renderBag.selectionCheckBox;
         },
         renderHeader: (headerParams) => {
             return (React.createElement(React.Fragment, null,
@@ -149,7 +149,7 @@ export const Select = function (props) {
                 placeholder: props.placeholder,
             });
             const title = typeof customRenderValue === 'string' ? customRenderValue : '';
-            children = customRenderValue ? (React.createElement(Box, { display: 'flex', flexDirection: 'row', flex: 1, flexWrap: 'nowrap', alignItems: 'center', overflow: 'hidden' },
+            children = customRenderValue ? (React.createElement(Box, { display: 'flex', flexDirection: 'row', flex: 1, flexWrap: 'nowrap', alignItems: 'center', overflow: 'hidden', height: '100%' },
                 React.createElement("span", { title: title, "data-name": "multi-value-text", style: {
                         flex: '0 1 auto',
                         appearance: 'none',
@@ -466,7 +466,7 @@ export const Select = function (props) {
                 return {
                     ...baseStyle,
                     ...commonStyles(state), // height: 30,
-                    minHeight: props.size === 'small' ? 0 : 32,
+                    minHeight: props.size === 'small' ? 0 : '100%',
                     boxShadow: state.isFocused ? 'var(--ab-cmp-select-focused__box-shadow)' : 'none',
                     outline: state.isFocused ? 'var(--ab-cmp-select-focused__outline)' : 'none',
                     border: 'var(--ab-cmp-select__border)',

package/src/env.js

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

package/src/layout-manager/src/LayoutManagerModel.d.ts

@@ -62,26 +62,17 @@ export type ColumnAggregationModel = {
     aggFunc: string | true;
     weightedColumnId?: string;
 };
-export type AggregationColumnsModel = {
+export type AggregationColumnsModelItem = {
     ColumnId: string;
     AggFunc: ColumnAggregationModel;
-}[];
-type RowSummaryPosition = 'Top' | 'Bottom';
-export interface RowSummaryModel {
-    /**
-     * Where Row Summary appears - 'Top' or 'Bottom'
-     */
-    Position?: RowSummaryPosition;
-    /**
-     * Map of Columns with Summary Expressions
-     */
-    ColumnsMap: Record<string, string>;
-    /**
-     * Evaluates only currently filtered rows in the summary
-     * @defaultValue true
-     */
-    IncludeOnlyFilteredRows?: boolean;
-}
+};
+export type AggregationColumnsModel = AggregationColumnsModelItem[];
+export type PivotAggregationColumnsModel = (AggregationColumnsModelItem & {
+    TotalColumn?: boolean | 'before' | 'after' | {
+        PivotColumnId: string;
+        ShowTotal?: boolean | 'before' | 'after';
+    }[];
+})[];
 export interface TableLayoutModel extends BaseLayoutModel {
     TableColumns: string[];
     /**
@@ -96,6 +87,7 @@ export interface TableLayoutModel extends BaseLayoutModel {
      * @defaultValue 'single'
      */
     RowGroupDisplayType?: 'single' | 'multi';
+    PivotAggregationColumns?: never;
     PivotColumns?: never;
     PivotGroupedColumns?: never;
     PivotExpandLevel?: never;
@@ -110,13 +102,24 @@ export interface PivotLayoutModel extends BaseLayoutModel {
     /**
      * Columns showing aggregated values in Group Rows; 1st value in record is Column name, 2nd is either aggfunc (e.g. sum, avg etc.) or 'true' (to use default aggfunc)
      */
-    PivotAggregationColumns?: AggregationColumnsModel;
+    PivotAggregationColumns?: PivotAggregationColumnsModel;
     TableAggregationColumns?: never;
     /**
      * Columns which are row-grouped when the Layout is applied
      */
     PivotGroupedColumns?: string[];
     RowGroupedColumns?: never;
+    /**
+     * Display Grand Total Row at the top or bottom of the Pivot Table
+     */
+    GrandTotalRow?: 'top' | 'bottom' | boolean;
+    /**
+     * Display Total of all Pivot Columns before or after the Pivot Columns
+     */
+    GrandTotalColumn?: 'before' | 'after' | boolean;
+    /**
+     * Display automatically calculated Totals within EACH Pivot Column Group, in the position specified
+     */
+    PivotGroupTotalColumn?: 'before' | 'after' | boolean;
 }
 export type LayoutModel = TableLayoutModel | PivotLayoutModel;
-export {};

package/src/layout-manager/src/destructurePivotColumnId.d.ts

@@ -0,0 +1,10 @@
+import { ColDef } from 'ag-grid-enterprise';
+export declare function destructurePivotColumnId(colDef: ColDef, currentModel: {
+    pivotColIds: string[];
+    aggColIds: string[];
+}, logWarning: (message: string) => void): '!unknown!' | {
+    pivotColumnIds: string[];
+    pivotKeys: string[];
+    pivotColumnId: string;
+    aggregationColumnId?: string;
+};

package/src/layout-manager/src/destructurePivotColumnId.js

@@ -0,0 +1,80 @@
+// supports only pivotTotalColumns (aggregation total) and pivotGroupTotal
+// AG Grid builds the ID as: `pivot_${pivotCols.join('-')}_${pivotKeys.join('-')}_${measureColumnId}`
+// see https://github.com/ag-grid/ag-grid/blob/e0cfe533b55b75cdc148cdfb1a4e977731dc0712/packages/ag-grid-enterprise/src/pivot/pivotColDefService.ts#L454C16-L454C88
+export function destructurePivotColumnId(colDef, currentModel, logWarning) {
+    const { colId } = colDef;
+    // Basic validation
+    if (!colId?.startsWith('pivot_')) {
+        logWarning(`Column id must start with 'pivot_': ${colId}`);
+        return '!unknown!';
+    }
+    const hasSpecialChars = (arr) => arr.some((str) => str.includes('-') || str.includes('_'));
+    // AG Grid uses _ and - as delimiters
+    // if we have these special characters in the column IDs, we need to parse them differently
+    const colIdsOrKeysContainSpecialChars = hasSpecialChars(currentModel.pivotColIds) ||
+        hasSpecialChars(currentModel.aggColIds) ||
+        hasSpecialChars(colDef.pivotKeys || []);
+    // Fast path - no special characters
+    if (!colIdsOrKeysContainSpecialChars) {
+        // Split by underscore to get 4 parts
+        const parts = colId.split('_');
+        if (parts.length !== 4) {
+            logWarning(`Unsupported format of pivot total column id: ${colId}`);
+            return '!unknown!';
+        }
+        const [_pivotPrefix, pivotColsTxt, pivotKeysTxt, aggregationColumnId] = parts;
+        const pivotColumnIds = pivotColsTxt.split('-');
+        const pivotKeys = pivotKeysTxt.split('-');
+        const pivotColumnId = pivotColumnIds[pivotKeys.length - 1];
+        return {
+            pivotColumnIds,
+            pivotKeys,
+            pivotColumnId,
+            aggregationColumnId: aggregationColumnId !== '' ? aggregationColumnId : undefined,
+        };
+    }
+    // the complex path, where we have to handle the special characters
+    // Remove 'pivot_' prefix
+    const withoutPrefix = colId.slice(6);
+    // Check if it's a pivot group total
+    const isPivotGroupTotal = withoutPrefix.endsWith('_');
+    // Get pivot keys from colDef (more reliable than string parsing)
+    const pivotKeys = colDef.pivotKeys || [];
+    if (isPivotGroupTotal) {
+        // Remove trailing underscore for pivot group totals
+        const content = withoutPrefix.slice(0, -1);
+        // The remaining content should be the pivot columns
+        const pivotColumnIds = currentModel.pivotColIds.filter((id) => content.includes(id));
+        if (!pivotColumnIds.length) {
+            logWarning(`Could not identify pivot columns in: ${content}`);
+            return '!unknown!';
+        }
+        return {
+            pivotColumnIds,
+            pivotKeys,
+            pivotColumnId: pivotColumnIds[pivotKeys.length],
+        };
+    }
+    // For regular pivot columns, work backwards to find aggregation column
+    const parts = withoutPrefix.split('_');
+    const lastPart = parts[parts.length - 1];
+    // Find the longest matching aggregation column id from the end
+    const aggregationColumnId = currentModel.aggColIds.find((aggId) => lastPart.endsWith(aggId));
+    if (!aggregationColumnId) {
+        logWarning(`Could not identify aggregation column in: ${lastPart}`);
+        return '!unknown!';
+    }
+    // Remove aggregation part and get pivot columns
+    const withoutAgg = withoutPrefix.slice(0, -(aggregationColumnId.length + 1));
+    const pivotColumnIds = currentModel.pivotColIds.filter((id) => withoutAgg.includes(id));
+    if (!pivotColumnIds.length) {
+        logWarning(`Could not identify pivot columns in: ${withoutAgg}`);
+        return '!unknown!';
+    }
+    return {
+        pivotColumnIds,
+        pivotKeys,
+        pivotColumnId: pivotColumnIds[pivotKeys.length - 1],
+        aggregationColumnId,
+    };
+}

package/src/layout-manager/src/index.d.ts

@@ -69,7 +69,12 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     private computeColumnOrderAndVisibility;
     autoSizeColumns(columnIds?: string[]): false | string[];
     private applyPivotLayout;
+    applyPivotTotals(layout: PivotLayoutModel): void;
     applyPivotExpandLevel(layout: PivotLayoutModel): void;
     private withSuppressColumnAnimation;
+    private setupPivotTotals;
+    private isPivotRowTotalColDef;
+    private patchPivotTotalColumn;
+    private getPivotTotalColumnConfig;
 }
 export {};