@adaptabletools/adaptable-cjs 20.0.6 → 20.0.7-canary.1

package/src/agGrid/AdaptableAgGrid.js

@@ -101,6 +101,7 @@ const AdaptableColumn_1 = require("../AdaptableState/Common/AdaptableColumn");
 const agGridDataTypeDefinitions_1 = require("./agGridDataTypeDefinitions");
 const AgGridThemeAdapter_1 = require("./AgGridThemeAdapter");
 const VersionUpgrade20_1 = require("../migration/VersionUpgrade20");
+const adaptableOverrideCheck_1 = require("../Utilities/adaptableOverrideCheck");
 const LocalEventService_Prototype = ag_grid_enterprise_1.LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -614,6 +615,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 = (0, adaptableOverrideCheck_1.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 = (0, adaptableOverrideCheck_1.tagProvidedByAdaptable)((params) => {
+                return this.api.columnApi.internalApi.getColumnHeaderName(params);
+            });
+            return defaultColGroupDef;
+        });
         /**
          * `theme`
          */

package/src/agGrid/AgGridAdapter.js

@@ -378,6 +378,7 @@ 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

@@ -17,6 +17,7 @@ const AdaptableNumberEditor_1 = require("./editors/AdaptableNumberEditor");
 const AdaptableDateEditor_1 = require("./editors/AdaptableDateEditor");
 const AgGridExportAdapter_1 = require("./AgGridExportAdapter");
 const AdaptableHelper_1 = require("../Utilities/Helpers/AdaptableHelper");
+const adaptableOverrideCheck_1 = require("../Utilities/adaptableOverrideCheck");
 function getEditorForColumnDataType(columnDataType, variant) {
     if (columnDataType === 'number') {
         return variant === 'react' ? AdaptableNumberEditor_1.AdaptableReactNumberEditor : AdaptableNumberEditor_1.AdaptableNumberEditor;
@@ -376,19 +377,12 @@ 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_1.default.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 (!(0, adaptableOverrideCheck_1.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/env.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.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: 1744973638081 || Date.now(),
-    VERSION: "20.0.6" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1745430388589 || Date.now(),
+    VERSION: "20.0.7-canary.1" || '--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,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destructurePivotColumnId = void 0;
+// 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
+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,
+    };
+}
+exports.destructurePivotColumnId = destructurePivotColumnId;

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 {};

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

@@ -8,6 +8,8 @@ const normalizeLayoutModel_1 = require("./normalizeLayoutModel");
 const isLayoutEqual_1 = require("./isLayoutEqual");
 const simplifyLayoutModel_1 = require("./simplifyLayoutModel");
 const sortColumnIdsByOrder_1 = require("./sortColumnIdsByOrder");
+const destructurePivotColumnId_1 = require("./destructurePivotColumnId");
+const isPivotTotalColumn_1 = require("./isPivotTotalColumn");
 function flattenColDefs(colDefs) {
     const res = [];
     const iteration = (c) => {
@@ -120,8 +122,12 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
             }).bind(this);
         }
         this.setOptions(options);
+        // this ensures the grand total columns are positioned correctly (before/after) even when changed at runtime
+        // see https://www.ag-grid.com/react-data-grid/pivoting-column-groups/#changing-data-filters-and-configurations
+        this.gridApi.setGridOption('enableStrictPivotColumnOrder', true);
         this.setupEvents();
         this.indexColumns();
+        this.setupPivotTotals();
         globalThis.layoutManager = this;
     }
     destroy() {
@@ -255,6 +261,18 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
             PivotAggregationColumns: layout.TableAggregationColumns,
             PivotExpandLevel: prevLayout?.PivotExpandLevel ?? -1,
         };
+        const grandTotalRow = this.gridApi.getGridOption('grandTotalRow');
+        if (grandTotalRow) {
+            pivotLayout.GrandTotalRow = grandTotalRow;
+        }
+        const grandTotalColumn = this.gridApi.getGridOption('pivotRowTotals');
+        if (grandTotalColumn) {
+            pivotLayout.GrandTotalColumn = grandTotalColumn;
+        }
+        const pivotGroupTotalColumn = this.gridApi.getGridOption('pivotColumnGroupTotals');
+        if (pivotGroupTotalColumn) {
+            pivotLayout.PivotGroupTotalColumn = pivotGroupTotalColumn;
+        }
         return (0, simplifyLayoutModel_1.simplifyPivotLayoutModel)(pivotLayout);
     }
     getTableLayoutModelFromGrid() {
@@ -275,7 +293,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         let ColumnPinning = {};
         const gridState = this.gridApi.getState();
         const prevLayout = this.currentLayout;
-        const prevAggColumns = prevLayout?.TableAggregationColumns;
+        const prevAggColumns = prevLayout?.TableAggregationColumns ?? prevLayout?.PivotAggregationColumns;
         const prevAggColumnsMap = prevAggColumns?.reduce((acc, agg) => {
             acc[agg.ColumnId] = agg;
             return acc;
@@ -986,6 +1004,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         return columnIds;
     }
     applyPivotLayout(layout, options) {
+        this.applyPivotTotals(layout);
         const columnState = this.computeColumnStateForPivotLayout(layout);
         // by simply calling this.gridApi.applyColumnState(columnState)
         // the order of aggregations is not preserved/guaranteed by ag-grid
@@ -1013,6 +1032,50 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
             this.applyRowGroupValues(layout.RowGroupValues);
         }
     }
+    applyPivotTotals(layout) {
+        /**
+         * GrandTotalRow
+         */
+        if (layout.GrandTotalRow) {
+            const grandTotalRow = layout.GrandTotalRow === true || layout.GrandTotalRow === 'top'
+                ? 'top'
+                : layout.GrandTotalRow === 'bottom'
+                    ? 'bottom'
+                    : null;
+            this.gridApi.setGridOption('grandTotalRow', grandTotalRow);
+        }
+        else {
+            this.gridApi.setGridOption('grandTotalRow', null);
+        }
+        /**
+         * GrandTotalColumn
+         */
+        if (layout.GrandTotalColumn) {
+            const grandTotalColumn = layout.GrandTotalColumn === true || layout.GrandTotalColumn === 'before'
+                ? 'before'
+                : layout.GrandTotalColumn === 'after'
+                    ? 'after'
+                    : null;
+            this.gridApi.setGridOption('pivotRowTotals', grandTotalColumn);
+        }
+        else {
+            this.gridApi.setGridOption('pivotRowTotals', null);
+        }
+        /**
+         * PivotGroupTotalColumn
+         */
+        if (layout.PivotGroupTotalColumn) {
+            const pivotGroupTotalColumn = layout.PivotGroupTotalColumn === true || layout.PivotGroupTotalColumn === 'before'
+                ? 'before'
+                : layout.PivotGroupTotalColumn === 'after'
+                    ? 'after'
+                    : null;
+            this.gridApi.setGridOption('pivotColumnGroupTotals', pivotGroupTotalColumn);
+        }
+        else {
+            this.gridApi.setGridOption('pivotColumnGroupTotals', null);
+        }
+    }
     applyPivotExpandLevel(layout) {
         const PivotExpandLevel = layout.PivotExpandLevel ?? -1;
         const allDisplayedColumnGroups = this.gridApi.getAllDisplayedColumnGroups();
@@ -1048,5 +1111,108 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         }
         return res;
     }
+    setupPivotTotals() {
+        const _original_processPivotResultColDef = this.gridApi.getGridOption('processPivotResultColDef');
+        const _original_processPivotResultColGroupDef = this.gridApi.getGridOption('processPivotResultColGroupDef');
+        this.gridApi.setGridOption('processPivotResultColGroupDef', (colGroupDef) => {
+            _original_processPivotResultColGroupDef?.(colGroupDef);
+            if (!(0, isPivotLayoutModel_1.isPivotLayoutModel)(this.currentLayout)) {
+                return;
+            }
+            this.patchPivotTotalColumn(colGroupDef);
+        });
+    }
+    isPivotRowTotalColDef(colDef) {
+        return colDef.colId?.startsWith('PivotRowTotal_');
+    }
+    patchPivotTotalColumn(colGroupDef) {
+        const hasPivotTotalCols = (pivotLayout) => {
+            return pivotLayout.PivotAggregationColumns?.some((aggCol) => !!aggCol.TotalColumn);
+        };
+        if (!(0, isPivotLayoutModel_1.isPivotLayoutModel)(this.currentLayout) || !hasPivotTotalCols(this.currentLayout)) {
+            return;
+        }
+        const pivotRowTotalColDefsBefore = [];
+        const pivotRowTotalColDefsAfter = [];
+        const pivotTotalColDefsBefore = [];
+        const pivotTotalColDefsAfter = [];
+        const normalColDefs = [];
+        colGroupDef.children.forEach((colDef) => {
+            if (this.isPivotRowTotalColDef(colDef)) {
+                if (this.gridApi.getGridOption('pivotRowTotals') === 'after') {
+                    pivotRowTotalColDefsAfter.push(colDef);
+                }
+                else {
+                    pivotRowTotalColDefsBefore.push(colDef);
+                }
+                return;
+            }
+            if ((0, isPivotTotalColumn_1.isPivotTotalColumn)(colDef)) {
+                if (!colDef.colId.startsWith('pivot_')) {
+                    this.warn(`Pivot total column ${colDef.colId} is not prefixed with 'pivot_', skipping...`);
+                    return;
+                }
+                // we do this for all total cols, but we will hide the ones that are not visible
+                colDef.columnGroupShow = undefined;
+                const totalColConfig = this.getPivotTotalColumnConfig(colDef, this.currentLayout);
+                if (!totalColConfig.visible) {
+                    colDef.hide = true;
+                }
+                else {
+                    if (totalColConfig.position === 'after') {
+                        pivotTotalColDefsAfter.push(colDef);
+                    }
+                    else {
+                        pivotTotalColDefsBefore.push(colDef);
+                    }
+                }
+            }
+            else {
+                normalColDefs.push(colDef);
+            }
+        });
+        colGroupDef.children = [
+            ...pivotRowTotalColDefsBefore,
+            ...pivotTotalColDefsBefore,
+            ...normalColDefs,
+            ...pivotTotalColDefsAfter,
+            ...pivotRowTotalColDefsAfter,
+        ];
+    }
+    getPivotTotalColumnConfig(colDef, currentPivotLayout) {
+        const defaultHiddenConfig = {
+            visible: false,
+        };
+        const colIdInfo = (0, destructurePivotColumnId_1.destructurePivotColumnId)(colDef, {
+            pivotColIds: this.currentLayout.PivotColumns,
+            aggColIds: this.currentLayout.PivotAggregationColumns.map((col) => col.ColumnId),
+        }, (message) => this.warn(message));
+        if (colIdInfo === '!unknown!') {
+            return defaultHiddenConfig;
+        }
+        const { pivotColumnId, aggregationColumnId } = colIdInfo;
+        const layoutAggCol = currentPivotLayout.PivotAggregationColumns?.find((col) => col.ColumnId === aggregationColumnId);
+        if (!layoutAggCol) {
+            this.warn(`Pivot Totals: could NOT find aggregation(value) column with id ${aggregationColumnId}`);
+            return defaultHiddenConfig;
+        }
+        const layoutPivotTotalColumn = layoutAggCol.TotalColumn;
+        if (!layoutPivotTotalColumn) {
+            return defaultHiddenConfig;
+        }
+        if (Array.isArray(layoutPivotTotalColumn)) {
+            const pivotSpecificConfig = layoutPivotTotalColumn.find((config) => config.PivotColumnId === pivotColumnId);
+            return {
+                visible: pivotSpecificConfig && pivotSpecificConfig.ShowTotal !== false,
+                position: pivotSpecificConfig?.ShowTotal === 'after' ? 'after' : 'before',
+            };
+        }
+        else {
+            return {
+                visible: !!layoutPivotTotalColumn,
+                position: layoutPivotTotalColumn === 'after' ? 'after' : 'before',
+            };
+        }
+    }
 }
 exports.LayoutManager = LayoutManager;

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

@@ -0,0 +1,2 @@
+import { ColDef } from 'ag-grid-enterprise';
+export declare function isPivotGroupTotalColumn(colDef: ColDef): boolean;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPivotGroupTotalColumn = void 0;
+function isPivotGroupTotalColumn(colDef) {
+    // pivot group total are spanning cross all aggregations
+    // therefore the last part of the colId is empty (hence the "dangling" underscore)
+    return colDef.colId?.startsWith('pivot_') && colDef.colId?.endsWith('_');
+}
+exports.isPivotGroupTotalColumn = isPivotGroupTotalColumn;

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

@@ -0,0 +1,2 @@
+import { ColDef } from 'ag-grid-enterprise';
+export declare function isPivotTotalColumn(colDef: ColDef): colDef is ColDef;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPivotTotalColumn = void 0;
+function isPivotTotalColumn(colDef) {
+    return !!colDef.pivotTotalColumnIds?.length;
+}
+exports.isPivotTotalColumn = isPivotTotalColumn;

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

@@ -144,6 +144,9 @@ function normalizePivotLayoutModel(layout) {
         // make it an own property
         layout.SuppressAggFuncInHeader = undefined;
     }
+    if (!layout.GrandTotalRow) {
+        layout.GrandTotalRow = false;
+    }
     return layout;
 }
 exports.normalizePivotLayoutModel = normalizePivotLayoutModel;

package/src/metamodel/adaptable.metamodel.d.ts

@@ -2011,6 +2011,14 @@ export declare const ADAPTABLE_METAMODEL: {
             defVal: string;
             gridInfo?: undefined;
             noCode?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            gridInfo?: undefined;
+            noCode?: undefined;
+            defVal?: undefined;
         })[];
     };
     ColumnScope: {
@@ -4368,18 +4376,18 @@ export declare const ADAPTABLE_METAMODEL: {
             kind: string;
             desc: string;
             isOpt: boolean;
-            ref: string;
+            ref?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
-            isOpt?: undefined;
-            ref?: undefined;
+            isOpt: boolean;
+            ref: string;
         } | {
             name: string;
             kind: string;
             desc: string;
-            isOpt: boolean;
+            isOpt?: undefined;
             ref?: undefined;
         })[];
     };