@adaptabletools/adaptable 20.1.4 → 20.1.6

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

@@ -217,15 +217,43 @@ export class LayoutManager extends LMEmitter {
         }
         this.triggerGridLayoutChange(layout);
     }
-    triggerGridLayoutChange(layout) {
+    triggerGridLayoutChange(layout, prevLayout = this._prevFiredLayout, options) {
         layout = simplifyLayoutModel(layout);
-        const prevLayout = this._prevFiredLayout;
+        prevLayout = prevLayout ? simplifyLayoutModel(prevLayout) : undefined;
+        const shouldSkipTriggerChange = options?.skipTriggerChange === true;
         this._prevFiredLayout = layout;
         this.currentLayout = layout;
-        // emit an event that the layout has changed from the grid
-        this.emitSync('gridLayoutChanged', layout);
-        const log = this.debugger.extend('gridLayoutChanged');
-        log('current grid layout:', JSON.stringify(layout, null, 2), '\nprev layout:\n', prevLayout ? JSON.stringify(prevLayout, null, 2) : 'no prev layout', '\nchanges from prev to current:\n', getChanges(prevLayout, layout));
+        if ((!prevLayout?.RowGroupedColumns || !prevLayout?.RowGroupedColumns.length) &&
+            layout.RowGroupedColumns &&
+            layout.RowGroupedColumns.length > 0 &&
+            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);
+            unsupress();
+        }
+        if ((!prevLayout?.RowGroupedColumns || !prevLayout?.RowGroupedColumns.length) &&
+            layout.RowGroupedColumns &&
+            layout.RowGroupedColumns.length > 0 &&
+            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);
+            unsupress();
+        }
+        if (!shouldSkipTriggerChange) {
+            // emit an event that the layout has changed from the grid
+            this.emitSync('gridLayoutChanged', layout);
+            const log = this.debugger.extend('gridLayoutChanged');
+            const changes = getChanges(prevLayout, layout);
+            log('current grid layout:', JSON.stringify(layout, null, 2), '\nprev layout:\n', prevLayout ? JSON.stringify(prevLayout, null, 2) : 'no prev layout', '\nchanges from prev to current:\n', changes);
+        }
     }
     onChange(fn) {
         return this.on('gridLayoutChanged', fn);
@@ -260,6 +288,17 @@ export class LayoutManager extends LMEmitter {
         }
         delete layout.TableColumns;
         const pivotLayout = {
+            Ignore_Name: layout.Ignore_Name,
+            Ignore_GridFilter: layout.Ignore_GridFilter,
+            Ignore_ColumnFilters: layout.Ignore_ColumnFilters,
+            Ignore_ColumnHeaders: layout.Ignore_ColumnHeaders,
+            Ignore_AutoSizeColumns: layout.Ignore_AutoSizeColumns,
+            Ignore_RowSummaries: layout.Ignore_RowSummaries,
+            Ignore_IsReadOnly: layout.Ignore_IsReadOnly,
+            Ignore_Tags: layout.Ignore_Tags,
+            Ignore_Source: layout.Ignore_Source,
+            Ignore_AdaptableVersion: layout.Ignore_AdaptableVersion,
+            Ignore_Uuid: layout.Ignore_Uuid,
             PivotColumns,
             ColumnPinning: layout.ColumnPinning,
             ColumnSorts: layout.ColumnSorts,
@@ -423,6 +462,10 @@ export class LayoutManager extends LMEmitter {
             });
         }
         if (RowGroupedColumns && RowGroupedColumns.length) {
+            // if it's a new grouping, try and take it
+            const isGroupingNew = RowGroupedColumns &&
+                !this.currentLayout?.RowGroupedColumns &&
+                !this.currentLayout?.PivotGroupedColumns;
             if (this.currentLayout?.RowGroupValues) {
                 const currentRowGroupValues = this.currentLayout.RowGroupValues;
                 if (currentRowGroupValues.RowGroupDisplay === 'always-collapsed') {
@@ -436,18 +479,22 @@ export class LayoutManager extends LMEmitter {
                     };
                 }
                 else if (currentRowGroupValues.RowGroupDisplay === 'collapsed') {
-                    const ExpandedValues = this.getRowGroupNodePathsAs({
-                        expanded: true,
-                    });
+                    const ExpandedValues = isGroupingNew
+                        ? currentRowGroupValues.Values || []
+                        : this.getRowGroupNodePathsAs({
+                            expanded: true,
+                        });
                     RowGroupValues = {
                         RowGroupDisplay: 'collapsed',
                         Values: ExpandedValues,
                     };
                 }
                 else if (currentRowGroupValues.RowGroupDisplay === 'expanded') {
-                    const CollapsedValues = this.getRowGroupNodePathsAs({
-                        expanded: false,
-                    });
+                    const CollapsedValues = isGroupingNew
+                        ? currentRowGroupValues.Values || []
+                        : this.getRowGroupNodePathsAs({
+                            expanded: false,
+                        });
                     RowGroupValues = {
                         RowGroupDisplay: 'expanded',
                         Values: CollapsedValues,
@@ -455,7 +502,23 @@ export class LayoutManager extends LMEmitter {
                 }
             }
         }
+        else {
+            if (this.currentLayout?.RowGroupValues) {
+                RowGroupValues = this.currentLayout.RowGroupValues;
+            }
+        }
         const layout = simplifyTableLayoutModel({
+            Ignore_Name: this.currentLayout?.Ignore_Name || 'Default',
+            Ignore_GridFilter: this.currentLayout?.Ignore_GridFilter,
+            Ignore_ColumnFilters: this.currentLayout?.Ignore_ColumnFilters,
+            Ignore_ColumnHeaders: this.currentLayout?.Ignore_ColumnHeaders,
+            Ignore_AutoSizeColumns: this.currentLayout?.Ignore_AutoSizeColumns,
+            Ignore_RowSummaries: this.currentLayout?.Ignore_RowSummaries,
+            Ignore_IsReadOnly: this.currentLayout?.Ignore_IsReadOnly,
+            Ignore_Tags: this.currentLayout?.Ignore_Tags,
+            Ignore_Source: this.currentLayout?.Ignore_Source,
+            Ignore_AdaptableVersion: this.currentLayout?.Ignore_AdaptableVersion,
+            Ignore_Uuid: this.currentLayout?.Ignore_Uuid,
             TableColumns: TableColumns,
             ColumnVisibility,
             ColumnWidths: ColumnWidths,
@@ -668,18 +731,39 @@ export class LayoutManager extends LMEmitter {
     }
     setLayout(layout, options) {
         layout = normalizeLayoutModel(layout, { isTree: this.isTreeMode() });
+        const shouldSkipTriggerChange = options?.skipTriggerChange === true;
         const shouldSkipEqualityCheck = options?.force === true;
         if (!shouldSkipEqualityCheck && isLayoutEqual(this.currentLayout, layout)) {
             return false;
         }
+        const prevCurrent = this.currentLayout;
         this.silentSetCurrentLayout(layout);
         this.applyLayout(layout, options);
-        this.triggerGridLayoutChange(layout);
+        this.triggerGridLayoutChange(layout, prevCurrent, {
+            skipTriggerChange: shouldSkipTriggerChange,
+        });
         return true;
     }
     isCurrentLayoutPivot() {
         return this.currentLayout && isPivotLayoutModel(this.currentLayout);
     }
+    suspendAgGridListener() {
+        if (this.supressGlobalAgGridEventTimeoutId) {
+            clearTimeout(this.supressGlobalAgGridEventTimeoutId);
+            this.supressGlobalAgGridEventTimeoutId = null;
+        }
+        this.suppressGlobalAgGridEventListener = true;
+        return () => this.resumeAgGridListener();
+    }
+    resumeAgGridListener(options) {
+        if (options?.immediate) {
+            this.suppressGlobalAgGridEventListener = false;
+            return;
+        }
+        this.supressGlobalAgGridEventTimeoutId = setTimeout(() => {
+            this.suppressGlobalAgGridEventListener = false;
+        }, 0);
+    }
     applyLayout(layout, options) {
         this.warn('applyLayout', layout);
         // we want to do this supress/unsupress thing
@@ -688,16 +772,7 @@ export class LayoutManager extends LMEmitter {
         // 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
-        if (this.supressGlobalAgGridEventTimeoutId) {
-            clearTimeout(this.supressGlobalAgGridEventTimeoutId);
-            this.supressGlobalAgGridEventTimeoutId = null;
-        }
-        const unsuppress = () => {
-            this.supressGlobalAgGridEventTimeoutId = setTimeout(() => {
-                this.suppressGlobalAgGridEventListener = false;
-            }, 0);
-        };
-        this.suppressGlobalAgGridEventListener = true;
+        const resume = this.suspendAgGridListener();
         const pivotMode = this.gridApi.isPivotMode();
         if (!!layout.SuppressAggFuncInHeader !== !!this.gridApi.getGridOption('suppressAggFuncInHeader')) {
             this.gridApi.setGridOption('suppressAggFuncInHeader', !!layout.SuppressAggFuncInHeader);
@@ -721,7 +796,7 @@ export class LayoutManager extends LMEmitter {
                 perfApplyPivot.end();
             }
             finally {
-                unsuppress();
+                resume();
             }
             return;
         }
@@ -734,7 +809,7 @@ export class LayoutManager extends LMEmitter {
             perfApplyTable.end();
         }
         finally {
-            unsuppress();
+            resume();
         }
     }
     applyTableLayout(layout, options) {
@@ -821,7 +896,7 @@ export class LayoutManager extends LMEmitter {
     }
     computeColumnStateForPivotLayout(layout) {
         let columnState = {};
-        const pivotColumnsToIndexes = layout.PivotColumns.reduce((acc, colId, index) => {
+        const pivotColumnsToIndexes = (layout.PivotColumns || []).reduce((acc, colId, index) => {
             acc[colId] = index;
             return acc;
         }, {});
@@ -834,10 +909,6 @@ export class LayoutManager extends LMEmitter {
             ...layout.PivotColumns,
             ...(layout.PivotAggregationColumns || []).map((col) => col.ColumnId),
         ], this.gridApi.getColumnDefs());
-        const pivotAggsToIndexes = layout.PivotAggregationColumns.reduce((acc, { ColumnId }, index) => {
-            acc[ColumnId] = index;
-            return acc;
-        }, {});
         columnState.state = columnIds.map((columnId) => {
             const pivotIndex = pivotColumnsToIndexes[columnId];
             const rowGroupIndex = rowGroupColumnIndexes[columnId];

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

@@ -47,8 +47,17 @@ export function isTableLayoutEqual(l1, l2) {
 }
 //#clearIgnoredProperties
 function clearIgnoredProperties(layout) {
-    delete layout.GridFilter;
-    delete layout.ColumnFilters;
+    delete layout.Ignore_GridFilter;
+    delete layout.Ignore_ColumnFilters;
+    delete layout.Ignore_Name;
+    delete layout.Ignore_ColumnHeaders;
+    delete layout.Ignore_AutoSizeColumns;
+    delete layout.Ignore_RowSummaries;
+    delete layout.Ignore_IsReadOnly;
+    delete layout.Ignore_Tags;
+    delete layout.Ignore_Source;
+    delete layout.Ignore_AdaptableVersion;
+    delete layout.Ignore_Uuid;
 }
 export function isPivotLayoutEqual(l1, l2) {
     l1 = normalizePivotLayoutModel(l1);

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

@@ -13,6 +13,9 @@ export function normalizeTableLayoutModel(layout, options) {
     if (!layout.TableAggregationColumns) {
         layout.TableAggregationColumns = [];
     }
+    if (!layout.Ignore_ColumnFilters) {
+        layout.Ignore_ColumnFilters = [];
+    }
     if (!layout.ColumnSorts) {
         layout.ColumnSorts = [];
     }
@@ -113,6 +116,9 @@ export function normalizePivotLayoutModel(layout) {
     if (!layout.ColumnVisibility) {
         layout.ColumnVisibility = {};
     }
+    if (!layout.Ignore_ColumnFilters) {
+        layout.Ignore_ColumnFilters = [];
+    }
     if (!layout.PivotAggregationColumns) {
         layout.PivotAggregationColumns = [];
     }

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

@@ -11,6 +11,9 @@ export function simplifyTableLayoutModel(layout) {
     if (layout.ColumnSorts && !layout.ColumnSorts.length) {
         delete layout.ColumnSorts;
     }
+    if (layout.Ignore_ColumnFilters && !layout.Ignore_ColumnFilters) {
+        delete layout.Ignore_ColumnFilters;
+    }
     if (layout.RowGroupedColumns && !layout.RowGroupedColumns.length) {
         delete layout.RowGroupedColumns;
     }
@@ -72,9 +75,6 @@ export function simplifyPivotLayoutModel(layout) {
     if (layout.ColumnSorts && !layout.ColumnSorts.length) {
         delete layout.ColumnSorts;
     }
-    if (!layout.PivotGroupedColumns && layout.RowGroupValues) {
-        delete layout.RowGroupValues;
-    }
     if (layout.GrandTotalRow === undefined) {
         delete layout.GrandTotalRow;
     }