@adaptabletools/adaptable 23.0.4 → 23.0.5-canary.0

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

@@ -59,13 +59,6 @@ function findInColDefs(colDefs, callback) {
 }
 const DEFAULT_COLUMN_WIDTH = 200;
 const DEFAULT_AGG_FUNC = 'sum';
-/**
- *
- * @param columnIds the column ids that we want to be in the order
- * @param colDefs all the colDefs in the grid
- * @returns the array of the given column ids, but also any other column id that is not in the given column ids, but
- * has a column definition
- */
 function getColumnOrderIdsForAllColDefs(columnIds = [], colDefs) {
     const flatColDefs = flattenColDefs(colDefs);
     const flatColIds = flatColDefs.map((c) => c.colId ?? c.field);
@@ -85,11 +78,6 @@ const COLUMN_EVENTS_THAT_TRIGGERS_AUTO_LAYOUT_SAVE = {
     sortChanged: true,
     columnRowGroupChanged: true,
     ...EXPAND_COLLAPSE_EVENTS,
-    // TODO check if all of those are needed
-    // stateUpdated: true,
-    // columnPinned: true,
-    // columnPivotChanged: true,
-    // columnValueChanged: true,
 };
 function isGridLayoutSame(options) {
     const { layoutFromGrid: gridLayout, layoutFromModel: layout } = options;
@@ -109,8 +97,6 @@ function getDefaultColumnSizeStateForColDef(colId, colDef, options) {
         ...options?.defaultColDef,
     };
     if (options?.colTypes) {
-        // for col sizing, we want the columns sized as flex via col.type and defaultColDef
-        // to be sized as flex, even if they are not in the layout.ColumnSizing object
         let colType = colDef?.type;
         if (colType && !Array.isArray(colType)) {
             colType = colType.split(',');
@@ -176,13 +162,10 @@ export class LayoutManager extends LMEmitter {
         }
         this.initialRowSelection = options.initialRowSelection;
         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 as any).layoutManager = this;
     }
     destroy() {
         if (this.destroyed) {
@@ -231,22 +214,16 @@ export class LayoutManager extends LMEmitter {
             if (type === 'columnResized' && !event.finished) {
                 return;
             }
-            // called while dragging a column from the sidebar, to the row groups panel
             if (type === 'displayedColumnsChanged' && event.source === 'uiColumnDragged') {
                 return;
             }
             this.warn(`globalAgGridEventListener-${type}`, event);
             if (!this.currentLayout) {
                 const gridLayout = this.getLayoutModelFromGrid();
-                // if there's no layout set currently in AG Grid
-                // then emit the gridLayoutChanged event directly
-                // as we don't have a current layout to compare to
                 this.onGridLayoutChanged(gridLayout);
                 return;
             }
             const gridLayout = this.getLayoutModelFromGrid();
-            // but if we do have a current layout set
-            // then only emit the event if the layout has changed
             if (!isGridLayoutSame({
                 layoutFromGrid: gridLayout,
                 layoutFromModel: this.currentLayout,
@@ -285,28 +262,16 @@ export class LayoutManager extends LMEmitter {
                 this.idsToFields[colId] = field;
             }
             this.idsToColDefs[colId] = colDef;
-            // const col = this.gridApi.getColumn(colId);
-            // this.initialColumnWidths[colId] = colDef.width ?? colDef.initialWidth ?? DEFAULT_COLUMN_WIDTH; // this.gridApi.getColumn(colId).getActualWidth();
-            // this.initialColumnWidths[colId] = col.getActualWidth();
             this.initialColumnWidths[colId] = this.getDefaultColumnWidthForCol(colId, colDef);
             const rowGroupColumns = this.gridApi.getRowGroupColumns() ?? [];
             rowGroupColumns.forEach((column) => {
                 const colId = column.getColId();
-                // const col = this.gridApi.getColumn(colId);
-                // const colDef = col.getColDef();
                 this.initialColumnWidths[colId] = this.getDefaultColumnWidthForCol(colId);
-                // colDef.width ?? colDef.initialWidth ?? DEFAULT_COLUMN_WIDTH;
             });
         };
         colDefs.forEach(iteration);
     }
     onGridLayoutChanged(layout) {
-        // we want to have this check, since onGridLayoutChanged might be triggered
-        // by some AG Grid actions we're not interested - eg: filter changed
-        // and the state of which is not captured by the Layout Model
-        // so it would result in a layout object that's similar to the previous one
-        // that we fired
-        // hence we need this check here as well
         if (this._prevFiredLayout && isLayoutEqual(layout, this._prevFiredLayout)) {
             return;
         }
@@ -322,16 +287,11 @@ export class LayoutManager extends LMEmitter {
             layout.RowGroupedColumns.length > 0 &&
             (prevLayout?.RowGroupedColumns || []).join(',') !== layout.RowGroupedColumns.join(',') &&
             layout.RowGroupValues) {
-            // most likely the user has changed grouping via some AG Grid action
-            // and we need to make sure the expand/collapse state is applied
-            // but we want to suspend the listener
-            // as it would re-trigger another change
             const unsupress = this.suspendAgGridListener();
             this.applyRowGroupValues(layout.RowGroupValues, layout.RowGroupedColumns);
             unsupress();
         }
         if (!shouldSkipTriggerChange) {
-            // emit an event that the layout has changed from the grid
             this.emitSync('gridLayoutChanged', layout);
             const log = this.infoLogger.extend('gridLayoutChanged');
             const changes = getChanges(normalizeLayoutModel(prevLayout), normalizeLayoutModel(layout));
@@ -365,12 +325,10 @@ export class LayoutManager extends LMEmitter {
         let ColumnSizing = layout.ColumnSizing || {};
         let ColumnVisibility = { ...layout.ColumnVisibility };
         const storePivotResultColumns = !!prevLayout?.PivotResultColumnsOrder;
-        //let's also include the column widths of the pivotResult columns
         pivotResultColumns.forEach((col) => {
             const colId = col.getColId();
             const Width = col.getActualWidth();
             const initialWidth = this.initialColumnWidths[colId] ?? DEFAULT_COLUMN_WIDTH;
-            // but if the width is the initial/default width, don't include it in the ColumnSizing
             if (Width !== initialWidth) {
                 ColumnSizing[colId] = {
                     Width,
@@ -380,9 +338,6 @@ export class LayoutManager extends LMEmitter {
         if (!Object.keys(ColumnSizing).length) {
             ColumnSizing = undefined;
         }
-        // from column visibility, let's remove all columns that are not actually in the pivot layout
-        // since having normal table columns here will break the equality check
-        // so we only want to keep the group columns and the pivot result columns
         Object.keys(ColumnVisibility).forEach((colId) => {
             const isInLayout = pivotResultColumnsSet.has(colId) || colId.startsWith(AUTO_GROUP_COLUMN_ID__SINGLE);
             if (!isInLayout) {
@@ -420,8 +375,6 @@ export class LayoutManager extends LMEmitter {
             PivotExpandLevel: prevLayout?.PivotExpandLevel ?? -1,
         };
         if (storePivotResultColumns) {
-            // Save all pivot result columns (including hidden ones from collapsed
-            // groups) in their current order, so the order is fully preserved.
             const allPivotResultColumnsInOrder = this.gridApi
                 .getColumnState()
                 .filter((col) => pivotResultColumnsSet.has(col.colId));
@@ -464,11 +417,7 @@ export class LayoutManager extends LMEmitter {
         }, {});
         const ColumnVisibility = columnState.reduce((acc, colState) => {
             const colId = colState.colId;
-            // normally we take the initial width from this object
             let initialWidth = this.initialColumnWidths[colId];
-            // but if this is a group column
-            // we try to infer it from the default width (when display type is single)
-            // or from the respective group column (when display type is multi)
             if (initialWidth === undefined) {
                 if (colId === AUTO_GROUP_COLUMN_ID__SINGLE) {
                     const groupByColId = this.gridApi.getRowGroupColumns()[0]?.getColId();
@@ -486,12 +435,8 @@ export class LayoutManager extends LMEmitter {
                 colSizing.Flex = colState.flex;
                 ColumnSizing[colId] = colSizing;
             }
-            // and only add the col width to the layout ColumnSizing
-            // if it's different from the initial default column width
             else if (colState.width && initialWidth != colState.width) {
                 const colSizing = { ...ColumnSizing[colId] };
-                // Flex columns often report a computed width without flex in column state —
-                // keep explicit Flex sizing from the layout instead of replacing it with pixels.
                 if (colSizing.Flex == null) {
                     delete colSizing.Flex;
                     colSizing.Width = colState.width;
@@ -516,8 +461,6 @@ export class LayoutManager extends LMEmitter {
             return acc;
         }, {});
         if (gridState.pivot?.pivotMode && gridState.sort?.sortModel) {
-            // for pivot mode, we can't simply take the current sort from the ColumnState
-            // but we have to go via the sortModel from the grid state
             ColumnSorts = gridState.sort.sortModel.map((sort) => {
                 return {
                     ColumnId: sort.colId,
@@ -539,8 +482,6 @@ export class LayoutManager extends LMEmitter {
                 };
             });
         }
-        // if there's a current layout set
-        // we want to only return the AG Grid columns that are also in the current layout
         if (this.currentLayout &&
             this.currentLayout.TableColumns &&
             this.currentLayout.TableColumns.length > 0) {
@@ -556,19 +497,11 @@ export class LayoutManager extends LMEmitter {
                     });
                 }
             }
-            // if (this.isTreeMode()) {
-            //   // colsInLayout.add(GROUP_COLUMN_ID__SINGLE);
-            // }
             TableColumns = TableColumns.filter((colId) => {
                 if (colsInLayout.has(colId)) {
                     return true;
                 }
-                // we might hit an edge case where we ungroup one of the 2+ group cols
-                // in the current layout - in which case in the prev state of the current layout
-                // we had the group column
-                // but now we will need to include the current column
                 if (colsInLayout.has(`${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`)) {
-                    // ColumnVisibility[colId] = false;
                     return true;
                 }
                 const col = this.gridApi.getColumn(colId);
@@ -602,7 +535,6 @@ export class LayoutManager extends LMEmitter {
         }
         if (RowGroupedColumns && RowGroupedColumns.length) {
             const LayoutRowGroupedColumns = this.currentLayout?.RowGroupedColumns || this.currentLayout?.PivotGroupedColumns || [];
-            // if it's a new grouping, try and take it
             const isGroupingNew = RowGroupedColumns && RowGroupedColumns.join(',') !== LayoutRowGroupedColumns.join(',');
             if (this.currentLayout?.RowGroupValues) {
                 const currentRowGroupValues = this.currentLayout.RowGroupValues;
@@ -707,8 +639,6 @@ export class LayoutManager extends LMEmitter {
                 const isPivot = this.isCurrentLayoutPivot();
                 const currentColumnGroupState = this.gridApi
                     .getColumnGroupState()
-                    // if we're in a pivot layout, only include groups that are pivot groups
-                    // as there are other fake groups in the grid as well
                     .filter((state) => (isPivot ? state.groupId.startsWith('pivotGroup_') : true));
                 if (currentColumnGroupValues.ColumnGroupDisplay === 'expanded') {
                     const collapsedGroupIds = currentColumnGroupState
@@ -780,14 +710,6 @@ export class LayoutManager extends LMEmitter {
                     colDef = { ...colDef, maxWidth: colSizing.MaxWidth };
                     changed = true;
                 }
-                // this (width and flex) shouldn't be needed theoretically, as applyColumnState will apply sizing
-                // using the newly computed column state
-                // but for whatever reason, this is needed here, for some edge cases
-                // eg: when a layout has a column width a width and minWidth
-                // and then we create a new layout with a different width and different min width
-                // then if we don't have this code, the new layout might wrongly apply the previous
-                // minWidth as the current column width
-                // see #edge-case-min-width-width-mismatch
                 if (colSizing.Width !== undefined && colSizing.Width !== colDef.width) {
                     colDef = { ...colDef, width: colSizing.Width };
                 }
@@ -823,7 +745,6 @@ export class LayoutManager extends LMEmitter {
             console.warn('Setting TableColumns to empty array.');
             layout.TableColumns = [];
         }
-        // just in case the enduser provided falsy colIds, it will crash AG Grid internals
         layout.TableColumns = layout.TableColumns.filter((colId) => colId != undefined);
         layout = normalizeTableLayoutModel(layout, { isTree: _options?.isTree ?? false });
         const agGridState = {};
@@ -834,8 +755,6 @@ export class LayoutManager extends LMEmitter {
         const flatColDefs = flattenColDefs(colDefs);
         const colDefsById = new Map(flatColDefs.map((colDef) => [colDef.colId ?? colDef.field, colDef]));
         const getColDef = (colId) => colDefsById.get(colId);
-        // TODO to implement support for row selection in server-side row model
-        // agGridState.rowSelection = { ... }
         agGridState.columnVisibility = {
             hiddenColIds: flatColDefs
                 .filter((colDef) => {
@@ -925,7 +844,6 @@ export class LayoutManager extends LMEmitter {
                 aggregationModel: TableAggregationColumns.map(({ colId, aggFunc }) => {
                     if (aggFunc === true) {
                         const colDef = getColDef(colId);
-                        // fallback to SUM if no defaultAggFunc is defined
                         aggFunc = colDef?.defaultAggFunc || DEFAULT_AGG_FUNC;
                     }
                     return {
@@ -940,26 +858,9 @@ export class LayoutManager extends LMEmitter {
     static getAGGridInitialStateForPivotLayout(layout, colDefs) {
         layout = normalizePivotLayoutModel(layout);
         const agGridState = {};
-        // const columnIds = getColumnOrderIdsForAllColDefs([], colDefs);
-        // agGridState.columnOrder = {
-        //   orderedColIds: columnIds,
-        // };
         const flatColDefs = flattenColDefs(colDefs);
         const colDefsById = new Map(flatColDefs.map((colDef) => [colDef.colId ?? colDef.field, colDef]));
         const getColDef = (colId) => colDefsById.get(colId);
-        // agGridState.columnVisibility = {
-        //   hiddenColIds: flatColDefs
-        //     .filter((colDef) => {
-        //       const colId = colDef.colId ?? colDef.field;
-        //       return (
-        //         layout.ColumnVisibility?.[colId] === false ||
-        //         !layout.OrderedColumns.includes(colId) ||
-        //         colDef.hide ||
-        //         colDef.initialHide
-        //       );
-        //     })
-        //     .map((colDef) => colDef.colId ?? colDef.field),
-        // };
         agGridState.pivot = {
             pivotMode: true,
             pivotColIds: layout.PivotColumns,
@@ -1027,7 +928,6 @@ export class LayoutManager extends LMEmitter {
                 aggregationModel: PivotAggregationColumns.map(({ colId, aggFunc }) => {
                     if (aggFunc === true) {
                         const colDef = getColDef(colId);
-                        // fallback to SUM if no defaultAggFunc is defined
                         aggFunc = colDef?.defaultAggFunc || DEFAULT_AGG_FUNC;
                     }
                     return {
@@ -1044,8 +944,6 @@ export class LayoutManager extends LMEmitter {
             layout = normalizeLayoutModel(layout, { isTree: this.isTreeMode() });
         }
         this.currentLayout = layout;
-        // we do this in order to avoid firing the `gridLayoutChanged` event
-        // when actually applying the layout
         this._prevFiredLayout = layout;
     }
     setLayout(layout, options) {
@@ -1053,11 +951,6 @@ export class LayoutManager extends LMEmitter {
         const shouldSkipTriggerChange = options?.skipTriggerChange === true;
         const shouldSkipEqualityCheck = options?.force === true;
         if (!shouldSkipEqualityCheck && isLayoutEqual(this.currentLayout, layout)) {
-            // isLayoutEqual strips Ignore_* properties (ColumnHeaders, Filters, etc.)
-            // so even when grid-derived properties match, we must sync currentLayout
-            // to preserve any Ignore_* changes — otherwise getLayoutModelFromGrid
-            // will copy stale values from this.currentLayout
-            // this.currentLayout = layout;
             this.silentSetCurrentLayout(layout);
             return false;
         }
@@ -1091,12 +984,6 @@ export class LayoutManager extends LMEmitter {
     }
     applyLayout(layout, options) {
         this.warn('applyLayout', layout);
-        // we want to do this supress/unsupress thing
-        // as otherwise, our applyLayout will trigger an onChange event
-        // which could trigger another setLayout
-        // yes, we do check for same layout and bail out if it is the same
-        // but we still want to avoid this unnecessary initial loop
-        // which may cause more adaptable work
         const resume = this.suspendAgGridListener();
         const pivotMode = this.isInPivotMode();
         if (!!layout.SuppressAggFuncInHeader !== !!this.gridApi.getGridOption('suppressAggFuncInHeader')) {
@@ -1286,13 +1173,6 @@ export class LayoutManager extends LMEmitter {
         const rowSelection = LayoutManager.getGridOptionForRowSelectionFromLayout(layout.RowSelection, this.initialRowSelection);
         const prevRowSelection = this.gridApi.getGridOption('rowSelection');
         this.gridApi.setGridOption('rowSelection', rowSelection);
-        // AG Grid does not always refresh already-rendered cells in the selection
-        // column when `rowSelection.checkboxes` is changed at runtime via setGridOption
-        // (e.g. toggling `checkboxes` or `headerCheckbox`).
-        // In the React wrapper this is masked by React-driven re-renders, but in the vanilla integration
-        // the selection column keeps showing stale content until a manual
-        // `refreshCells` is triggered. We force the refresh here so
-        // all integrations behave consistently.
         if (typeof prevRowSelection === 'object' &&
             typeof rowSelection === 'object' &&
             rowSelection.checkboxes !== prevRowSelection.checkboxes) {
@@ -1307,9 +1187,6 @@ export class LayoutManager extends LMEmitter {
     applyTableLayout(layout, options) {
         this.withSuppressColumnAnimation(() => {
             this.ensureSelectionColumnPositionUnlocked(layout);
-            // if we apply the state here, before calling setGridOption for groupDisplayType
-            // the order is not always correctly applied
-            // this.gridApi.applyColumnState(state);
             const hasGroupedColumns = layout.RowGroupedColumns && layout.RowGroupedColumns.length;
             if (hasGroupedColumns) {
                 const displayTypeFromLayout = rowGroupDisplayTypeToGridOption(layout.RowGroupDisplayType);
@@ -1318,9 +1195,7 @@ export class LayoutManager extends LMEmitter {
                     this.gridApi.setGridOption('groupDisplayType', displayTypeFromLayout);
                 }
             }
-            // so we apply the state at the end
             this.gridApi.applyColumnState(this.computeColumnStateForTableLayout(layout));
-            // but also let's not forget to apply the row group values
             if (hasGroupedColumns && layout.RowGroupValues && !options?.skipApplyRowGroupsExpandedState) {
                 this.applyRowGroupValues(layout.RowGroupValues, layout.RowGroupedColumns);
             }
@@ -1388,11 +1263,9 @@ export class LayoutManager extends LMEmitter {
                         currentNode = currentNode.parent;
                     } while (currentNode.parent);
                     const shouldBeExpanded = defaultExpanded
-                        ? // by default nodes should be expanded
-                            // but this node should be expanded if it is not in the map
+                        ?
                             !deepMap.has(nodePath)
-                        : // by default nodes should be collapsed
-                            // but this node should be expanded if it is in the map
+                        :
                             deepMap.has(nodePath);
                     node.expanded = shouldBeExpanded;
                 }
@@ -1410,9 +1283,6 @@ export class LayoutManager extends LMEmitter {
             acc[colId] = index;
             return acc;
         }, {});
-        // having this set to true will change pivot column order when there is sorting
-        // and we don't want that to happen #keep-sorted-columns-in-same-order-as-unsorted
-        // columnState.applyOrder = true;
         const columnIds = getColumnOrderIdsForAllColDefs([
             ...layout.PivotColumns,
             ...(layout.PivotAggregationColumns || []).map((col) => col.ColumnId),
@@ -1432,10 +1302,6 @@ export class LayoutManager extends LMEmitter {
         this.computeColumnSorts(layout, columnState);
         this.computePinnedColumns(layout, columnState);
         this.computePivotAggregations(layout, columnState);
-        // Add pivot result columns to the state for ordering (will be applied with applyOrder: true later).
-        // Some pivot result columns may already be in the state (e.g. added by computeColumnSorts),
-        // so remove them first and re-add all pivot result columns in the persisted order,
-        // merging any existing state (like sort info) back in.
         if (Array.isArray(layout.PivotResultColumnsOrder)) {
             const pivotResultColumnsOrderSet = new Set(layout.PivotResultColumnsOrder);
             const existingPivotResultState = {};
@@ -1553,8 +1419,6 @@ export class LayoutManager extends LMEmitter {
         }, {});
         columnState.state.forEach((colState) => {
             const colSortIndex = sortsToIndexes[colState.colId];
-            // we delete them just to know if there are any left
-            // after the forEach is done
             delete sortsToIndexes[colState.colId];
             const colSort = sorts[colSortIndex];
             if (colSort != undefined) {
@@ -1567,8 +1431,6 @@ export class LayoutManager extends LMEmitter {
             }
         });
         if (Object.keys(sortsToIndexes).length) {
-            // if there are some sorts left which were not applied to the columnState
-            // probably those are for pivot result columns, so we need to apply them as well
             Object.keys(sortsToIndexes).forEach((colId) => {
                 const colSortIndex = sortsToIndexes[colId];
                 const colSort = sorts[colSortIndex];
@@ -1628,8 +1490,6 @@ export class LayoutManager extends LMEmitter {
             if (visibility[colId] === false) {
                 return true;
             }
-            // for the selection column, return true even
-            // if not explicitly listed in the TableColumns
             if (colId === LayoutManager.SELECTION_COLUMN_ID && layout.RowSelection) {
                 return false;
             }
@@ -1643,7 +1503,6 @@ export class LayoutManager extends LMEmitter {
                 colId: columnId,
                 hide: isColHidden(columnId),
                 pivot: false,
-                // @ts-ignore
                 pivotIndex: null,
             };
         });
@@ -1655,11 +1514,9 @@ export class LayoutManager extends LMEmitter {
         if (currentLayout) {
             tableColumns = currentLayout.TableColumns;
             if (currentLayout.ColumnVisibility) {
-                // dont auto size hidden columns
                 tableColumns = tableColumns.filter((colId) => !currentLayout.ColumnVisibility[colId]);
             }
             if (currentLayout.ColumnSizing) {
-                // dont auto size columns with a set sizing
                 tableColumns = tableColumns.filter((colId) => !currentLayout.ColumnSizing[colId]);
             }
         }
@@ -1682,34 +1539,16 @@ export class LayoutManager extends LMEmitter {
                 }
             }
             const columnState = this.computeColumnStateForPivotLayout(layout);
-            // by simply calling this.gridApi.applyColumnState(columnState)
-            // the order of aggregations is not preserved/guaranteed by ag-grid
-            // so we want to apply multiple states - adding aggregations one by one
-            // first: no aggregation
-            // second: [agg[0]]
-            // third: [agg[0], agg[1]]
-            // fourth: ...etc
-            // so we apply the states for all aggregations except the last one
-            //
             const aggregationsMapForOrder = (layout.PivotAggregationColumns || []).map((_, index) => layout.PivotAggregationColumns.slice(0, index));
             aggregationsMapForOrder.forEach((agg) => {
-                // we're mutating the columnState here
                 this.computePivotAggregations({ ...layout, PivotAggregationColumns: agg }, columnState);
-                // and apply the state
                 this.gridApi.applyColumnState(columnState);
             });
-            // now recompute and apply the last one
             this.computePivotAggregations(layout, columnState);
-            // Apply order only on the final call when PivotResultColumns is specified
             if (Array.isArray(layout.PivotResultColumnsOrder)) {
                 columnState.applyOrder = true;
             }
             this.gridApi.applyColumnState(columnState);
-            // let's also include the column widths of the pivotResult columns
-            // we can't simply include those in the columnState because the columnState will also apply order
-            // but we don't want to affect the order of the pivotResult columns
-            // so we'll do it manually, and apply the widths after the columnState
-            // by using the gridApi.setColumnWidths method
             if (layout.ColumnSizing) {
                 const colWidthForPivotResultColumns = [];
                 (this.gridApi.getPivotResultColumns() || []).forEach((col) => {
@@ -1726,20 +1565,12 @@ export class LayoutManager extends LMEmitter {
                 }
             }
             this.applyColumnGroupCollapseExpandState(layout);
-            // but also let's not forget to apply the row group values
             if (hasGroupedColumns && layout.RowGroupValues && !options?.skipApplyRowGroupsExpandedState) {
                 this.applyRowGroupValues(layout.RowGroupValues, layout.PivotGroupedColumns);
             }
         });
     }
     applyPivotTotals(layout) {
-        /**
-         * GrandTotalRow
-         */
-        // is common to both Table and Pivot and is applied in applyLayout()
-        /**
-         * PivotGrandTotal
-         */
         if (layout.PivotGrandTotal) {
             const pivotGrandTotal = layout.PivotGrandTotal === true || layout.PivotGrandTotal === 'before'
                 ? 'before'
@@ -1751,9 +1582,6 @@ export class LayoutManager extends LMEmitter {
         else {
             this.gridApi.setGridOption('pivotRowTotals', null);
         }
-        /**
-         * PivotColumnTotal
-         */
         if (layout.PivotColumnTotal) {
             const pivotColumnTotal = layout.PivotColumnTotal === true || layout.PivotColumnTotal === 'before'
                 ? 'before'
@@ -1776,7 +1604,6 @@ export class LayoutManager extends LMEmitter {
         }
         const colGroupDefs = allDisplayedColumnGroups
             .map((colGroup) => colGroup.getDefinition())
-            // we need to filter because there are some fake groups as well, no idea what for
             .filter(Boolean);
         const colGroupState = [];
         const columnGroupExceptions = ColumnGroupValues?.ColumnGroupDisplay === 'collapsed' ||
@@ -1840,10 +1667,6 @@ export class LayoutManager extends LMEmitter {
         }
         return res;
     }
-    /**
-     * Refreshes the sort order by refreshing the client side row model.
-     * This is useful when custom sort comparers are defined and the sort needs to be re-applied after filtering.
-     */
     refreshSort() {
         this.withSuppressRowAnimation(() => {
             this.gridApi.refreshClientSideRowModel('sort');
@@ -1908,7 +1731,6 @@ export class LayoutManager extends LMEmitter {
                     return;
                 }
                 this.patchColDefType(colDef, [PIVOT_ANY_TOTAL_COL_TYPE, PIVOT_AGGREGATION_TOTAL_COL_TYPE]);
-                // 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) {
@@ -1971,8 +1793,6 @@ export class LayoutManager extends LMEmitter {
         }
     }
     isInPivotMode() {
-        // SSRM comes with its own pivot module implementation
-        // see #ssrm_pivot_module
         const isModuleRegistered = this.gridApi.isModuleRegistered('PivotModule') ||
             this.gridApi.isModuleRegistered('ServerSideRowModelModule');
         return isModuleRegistered && this.gridApi.isPivotMode();

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

@@ -45,7 +45,6 @@ export function isTableLayoutEqual(l1, l2) {
     }
     return res;
 }
-//#clearIgnoredProperties
 function clearIgnoredProperties(layout) {
     delete layout.Ignore_GridFilter;
     delete layout.Ignore_ColumnFilters;

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

@@ -1,5 +1,3 @@
 export function isPivotColumnTotal(colId) {
-    // pivot group total are spanning cross all aggregations
-    // therefore the last part of the colId is empty (hence the "dangling" underscore)
     return colId?.startsWith('pivot_') && colId?.endsWith('_');
 }

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

@@ -29,23 +29,16 @@ export function normalizeTableLayoutModel(layout, options) {
         layout.RowGroupedColumns = [];
     }
     if (!('SuppressAggFuncInHeader' in layout)) {
-        // make it an own property
         layout.SuppressAggFuncInHeader = undefined;
     }
     if (!('GrandTotalRow' in layout)) {
-        // make it an own property
         layout.GrandTotalRow = undefined;
     }
     if (!('RowSelection' in layout)) {
-        // make it an own property
         layout.RowSelection = undefined;
     }
     const ColumnOrderSet = new Set(layout.TableColumns);
     if (layout.RowGroupedColumns && layout.RowGroupedColumns.length && layout.TableColumns) {
-        // the layout.TableColumns might not include the group columns
-        //
-        // but we want to include those columnIds in the TableColumns
-        // so the layout is properly specified
         let displayType = layout.RowGroupDisplayType;
         if (!displayType) {
             layout.TableColumns.some((columnId) => {
@@ -74,30 +67,20 @@ export function normalizeTableLayoutModel(layout, options) {
             [...layout.RowGroupedColumns].reverse().forEach((colId) => {
                 const groupColId = `${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
                 if (!ColumnOrderSet.has(groupColId) && !ColumnOrderSet.has(colId)) {
-                    // add the col to the beginning of the layout.OrderedColumns
                     layout.TableColumns.unshift(colId);
                     ColumnOrderSet.add(colId);
-                    // the .flatMap below will handle the rest
                 }
             });
             const MappedColumnOrder = layout.TableColumns.flatMap((colId) => {
                 if (GroupedCols.has(colId)) {
-                    // if the column is grouped by
                     const groupColId = `${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
-                    // but there's no column for this group in the layout
                     if (!ColumnOrderSet.has(groupColId)) {
-                        // then we assume that the current column is basically the group column
-                        // so we return both the group column and the current column
-                        // but make the current column hidden
                         layout.ColumnVisibility[colId] = false;
                         return [groupColId, colId];
                     }
                 }
-                // if this is a group column
                 if (colId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX)) {
                     const simpleColId = colId.replace(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, '');
-                    // but the corresponding simple column is not in the layout
-                    // then let's include it, with visibility set to false
                     if (!ColumnOrderSet.has(simpleColId)) {
                         layout.ColumnVisibility[simpleColId] = false;
                         return [colId, simpleColId];
@@ -113,8 +96,6 @@ export function normalizeTableLayoutModel(layout, options) {
             };
         }
     }
-    // there might be a case where there are we have an RowGroupedColumns array, but it's empty (or it's inexistent altogether)
-    // and there is no display type specified - so default it to single
     if (!layout.RowGroupDisplayType && layout.TableColumns) {
         layout.RowGroupDisplayType = 'single';
     }
@@ -161,28 +142,21 @@ export function normalizePivotLayoutModel(layout) {
         };
     }
     if (!('SuppressAggFuncInHeader' in layout)) {
-        // make it an own property
         layout.SuppressAggFuncInHeader = undefined;
     }
     if (!('GrandTotalRow' in layout)) {
-        // make it an own property
         layout.GrandTotalRow = undefined;
     }
     if (!('PivotGrandTotal' in layout)) {
-        // make it an own property
         layout.PivotGrandTotal = undefined;
     }
     if (!('PivotColumnTotal' in layout)) {
-        // make it an own property
         layout.PivotColumnTotal = undefined;
     }
     if (!('RowSelection' in layout)) {
-        // make it an own property
         layout.RowSelection = undefined;
     }
-    // if (layout.PivotGroupedColumns && layout.PivotGroupedColumns.length) {
     layout.RowGroupDisplayType = layout.RowGroupDisplayType || 'single';
-    // }
     return layout;
 }
 export function normalizeLayoutModel(layout, options) {
@@ -191,5 +165,4 @@ export function normalizeLayoutModel(layout, options) {
     }
     return normalizeTableLayoutModel(layout, options);
 }
-//@ts-ignore
 globalThis.normalizeTableLayoutModel = normalizeTableLayoutModel;