@adaptabletools/adaptable 20.0.10 → 20.0.12

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

@@ -2,13 +2,17 @@ import { debounce, DeepMap } from '@infinite-table/infinite-react';
 import { isPivotLayoutModel } from './isPivotLayoutModel';
 import { LMEmitter } from './LMEmitter';
 import { GROUP_COLUMN_ID__MULTI_PREFIX, GROUP_COLUMN_ID__SINGLE, normalizeLayoutModel, normalizePivotLayoutModel, normalizeTableLayoutModel, } from './normalizeLayoutModel';
-import { isLayoutEqual } from './isLayoutEqual';
+import { isLayoutEqual, getChanges } from './isLayoutEqual';
 import { simplifyLayoutModel, simplifyPivotLayoutModel, simplifyTableLayoutModel, } from './simplifyLayoutModel';
 import { sortColumnIdsByOrder } from './sortColumnIdsByOrder';
 import { destructurePivotColumnId } from './destructurePivotColumnId';
 import { isPivotAggTotalColumn } from './isPivotAggTotalColumn';
-import { isPivotGrandTotalColumn } from './isPivotGrandTotalColumn';
-import { isPivotGroupTotalColumn } from './isPivotGroupTotalColumn';
+import { isPivotGrandTotal } from './isPivotGrandTotal';
+import { isPivotColumnTotal } from './isPivotColumnTotal';
+export const PIVOT_ANY_TOTAL_COL_TYPE = 'pivotAnyTotal';
+export const PIVOT_GRAND_TOTAL_COL_TYPE = 'pivotGrandTotal';
+export const PIVOT_COLUMN_TOTAL_COL_TYPE = 'pivotColumnTotal';
+export const PIVOT_AGGREGATION_TOTAL_COL_TYPE = 'pivotAggregationTotal';
 function flattenColDefs(colDefs) {
     const res = [];
     const iteration = (c) => {
@@ -224,7 +228,7 @@ export class LayoutManager extends LMEmitter {
         // 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');
+        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));
     }
     onChange(fn) {
         return this.on('gridLayoutChanged', fn);
@@ -264,13 +268,13 @@ export class LayoutManager extends LMEmitter {
         if (layout.SuppressAggFuncInHeader) {
             pivotLayout.SuppressAggFuncInHeader = layout.SuppressAggFuncInHeader;
         }
-        const grandTotalColumn = this.gridApi.getGridOption('pivotRowTotals');
-        if (grandTotalColumn) {
-            pivotLayout.GrandTotalColumn = grandTotalColumn;
+        const pivotGrandTotal = this.gridApi.getGridOption('pivotRowTotals');
+        if (pivotGrandTotal) {
+            pivotLayout.PivotGrandTotal = pivotGrandTotal;
         }
-        const pivotGroupTotalColumn = this.gridApi.getGridOption('pivotColumnGroupTotals');
-        if (pivotGroupTotalColumn) {
-            pivotLayout.PivotGroupTotalColumn = pivotGroupTotalColumn;
+        const pivotColumnTotal = this.gridApi.getGridOption('pivotColumnGroupTotals');
+        if (pivotColumnTotal) {
+            pivotLayout.PivotColumnTotal = pivotColumnTotal;
         }
         return simplifyPivotLayoutModel(pivotLayout);
     }
@@ -1048,29 +1052,29 @@ export class LayoutManager extends LMEmitter {
          */
         // is common to both Table and Pivot and is applied in applyLayout()
         /**
-         * GrandTotalColumn
+         * PivotGrandTotal
          */
-        if (layout.GrandTotalColumn) {
-            const grandTotalColumn = layout.GrandTotalColumn === true || layout.GrandTotalColumn === 'before'
+        if (layout.PivotGrandTotal) {
+            const pivotGrandTotal = layout.PivotGrandTotal === true || layout.PivotGrandTotal === 'before'
                 ? 'before'
-                : layout.GrandTotalColumn === 'after'
+                : layout.PivotGrandTotal === 'after'
                     ? 'after'
                     : null;
-            this.gridApi.setGridOption('pivotRowTotals', grandTotalColumn);
+            this.gridApi.setGridOption('pivotRowTotals', pivotGrandTotal);
         }
         else {
             this.gridApi.setGridOption('pivotRowTotals', null);
         }
         /**
-         * PivotGroupTotalColumn
+         * PivotColumnTotal
          */
-        if (layout.PivotGroupTotalColumn) {
-            const pivotGroupTotalColumn = layout.PivotGroupTotalColumn === true || layout.PivotGroupTotalColumn === 'before'
+        if (layout.PivotColumnTotal) {
+            const pivotColumnTotal = layout.PivotColumnTotal === true || layout.PivotColumnTotal === 'before'
                 ? 'before'
-                : layout.PivotGroupTotalColumn === 'after'
+                : layout.PivotColumnTotal === 'after'
                     ? 'after'
                     : null;
-            this.gridApi.setGridOption('pivotColumnGroupTotals', pivotGroupTotalColumn);
+            this.gridApi.setGridOption('pivotColumnGroupTotals', pivotColumnTotal);
         }
         else {
             this.gridApi.setGridOption('pivotColumnGroupTotals', null);
@@ -1126,11 +1130,11 @@ export class LayoutManager extends LMEmitter {
             if (!isPivotLayoutModel(this.currentLayout)) {
                 return;
             }
-            if (isPivotGrandTotalColumn(colDef)) {
-                this.patchColDefType(colDef, ['pivotTotalColumn', 'pivotGrandTotalColumn']);
+            if (isPivotGrandTotal(colDef)) {
+                this.patchColDefType(colDef, [PIVOT_ANY_TOTAL_COL_TYPE, PIVOT_GRAND_TOTAL_COL_TYPE]);
             }
-            if (isPivotGroupTotalColumn(colDef.colId)) {
-                this.patchColDefType(colDef, ['pivotTotalColumn', 'pivotGroupTotalColumn']);
+            if (isPivotColumnTotal(colDef.colId)) {
+                this.patchColDefType(colDef, [PIVOT_ANY_TOTAL_COL_TYPE, PIVOT_COLUMN_TOTAL_COL_TYPE]);
             }
         });
         const _original_processPivotResultColGroupDef = this.gridApi.getGridOption('processPivotResultColGroupDef');
@@ -1139,28 +1143,28 @@ export class LayoutManager extends LMEmitter {
             if (!isPivotLayoutModel(this.currentLayout)) {
                 return;
             }
-            this.patchPivotTotalColumn(colGroupDef);
+            this.patchPivotAggregationTotal(colGroupDef);
         });
     }
-    patchPivotTotalColumn(colGroupDef) {
-        const hasPivotTotalCols = (pivotLayout) => {
-            return pivotLayout.PivotAggregationColumns?.some((aggCol) => !!aggCol.TotalColumn);
+    patchPivotAggregationTotal(colGroupDef) {
+        const hasPivotAggTotals = (pivotLayout) => {
+            return pivotLayout.PivotAggregationColumns?.some((aggCol) => !!aggCol.Total);
         };
-        if (!isPivotLayoutModel(this.currentLayout) || !hasPivotTotalCols(this.currentLayout)) {
+        if (!isPivotLayoutModel(this.currentLayout) || !hasPivotAggTotals(this.currentLayout)) {
             return;
         }
-        const pivotRowTotalColDefsBefore = [];
-        const pivotRowTotalColDefsAfter = [];
-        const pivotTotalColDefsBefore = [];
-        const pivotTotalColDefsAfter = [];
+        const pivotGrandTotalsBefore = [];
+        const pivotGrandTotalsAfter = [];
+        const pivotAggTotalsBefore = [];
+        const pivotAggTotalsAfter = [];
         const normalColDefs = [];
         colGroupDef.children.forEach((colDef) => {
-            if (isPivotGrandTotalColumn(colDef)) {
+            if (isPivotGrandTotal(colDef)) {
                 if (this.gridApi.getGridOption('pivotRowTotals') === 'after') {
-                    pivotRowTotalColDefsAfter.push(colDef);
+                    pivotGrandTotalsAfter.push(colDef);
                 }
                 else {
-                    pivotRowTotalColDefsBefore.push(colDef);
+                    pivotGrandTotalsBefore.push(colDef);
                 }
                 return;
             }
@@ -1169,7 +1173,7 @@ export class LayoutManager extends LMEmitter {
                     this.warn(`Pivot total column ${colDef.colId} is not prefixed with 'pivot_', skipping...`);
                     return;
                 }
-                this.patchColDefType(colDef, ['pivotTotalColumn', 'pivotAggregationTotalColumn']);
+                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);
@@ -1178,10 +1182,10 @@ export class LayoutManager extends LMEmitter {
                 }
                 else {
                     if (totalColConfig.position === 'after') {
-                        pivotTotalColDefsAfter.push(colDef);
+                        pivotAggTotalsAfter.push(colDef);
                     }
                     else {
-                        pivotTotalColDefsBefore.push(colDef);
+                        pivotAggTotalsBefore.push(colDef);
                     }
                 }
             }
@@ -1190,11 +1194,11 @@ export class LayoutManager extends LMEmitter {
             }
         });
         colGroupDef.children = [
-            ...pivotRowTotalColDefsBefore,
-            ...pivotTotalColDefsBefore,
+            ...pivotGrandTotalsBefore,
+            ...pivotAggTotalsBefore,
             ...normalColDefs,
-            ...pivotTotalColDefsAfter,
-            ...pivotRowTotalColDefsAfter,
+            ...pivotAggTotalsAfter,
+            ...pivotGrandTotalsAfter,
         ];
     }
     getPivotTotalColumnConfig(colDef, currentPivotLayout) {
@@ -1214,7 +1218,7 @@ export class LayoutManager extends LMEmitter {
             this.warn(`Pivot Totals: could NOT find aggregation(value) column with id ${aggregationColumnId}`);
             return defaultHiddenConfig;
         }
-        const layoutPivotTotalColumn = layoutAggCol.TotalColumn;
+        const layoutPivotTotalColumn = layoutAggCol.Total;
         if (!layoutPivotTotalColumn) {
             return defaultHiddenConfig;
         }

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

@@ -1,4 +1,12 @@
 import { PivotLayoutModel, TableLayoutModel } from './LayoutManagerModel';
+declare const logger: import("@infinite-table/infinite-react").DebugLogger;
+export declare const getChanges: (l1: any, l2: any) => {
+    key: string;
+    value1: any;
+    value2: any;
+}[];
+export declare const logChanges: (l1: any, l2: any, log?: typeof logger) => void;
 export declare function isTableLayoutEqual(l1: TableLayoutModel, l2: TableLayoutModel): boolean;
 export declare function isPivotLayoutEqual(l1: PivotLayoutModel, l2: PivotLayoutModel): boolean;
 export declare function isLayoutEqual(l1: TableLayoutModel | PivotLayoutModel, l2: TableLayoutModel | PivotLayoutModel): boolean;
+export {};

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

@@ -1,15 +1,56 @@
 import isDeepEqual from 'lodash/isEqual';
+import { debug as debugFactory } from '@infinite-table/infinite-react';
 import { isPivotLayoutModel } from './isPivotLayoutModel';
 import { normalizePivotLayoutModel, normalizeTableLayoutModel } from './normalizeLayoutModel';
+const logger = debugFactory(`LayoutManager:Diffing`);
+export const getChanges = (l1, l2) => {
+    if (!l1 || typeof l1 !== 'object' || !l2 || typeof l2 !== 'object') {
+        return [
+            {
+                key: 'missing',
+                value1: l1,
+                value2: l2,
+            },
+        ];
+    }
+    const k1 = Object.keys(l1);
+    const k2 = Object.keys(l2);
+    const allKeys = new Set([...k1, ...k2]);
+    const changes = [];
+    for (const key of allKeys) {
+        if (!isDeepEqual(l1[key], l2[key])) {
+            changes.push({ key, value1: l1[key], value2: l2[key] });
+        }
+    }
+    return changes;
+};
+export const logChanges = (l1, l2, log) => {
+    log = log || logger;
+    const changes = getChanges(l1, l2);
+    log('---');
+    log('Layouts are not equal.');
+    log('Layout 1', l1);
+    log('Layout 2', l2);
+    log('Differences:', changes);
+    log('---');
+};
 export function isTableLayoutEqual(l1, l2) {
     l1 = normalizeTableLayoutModel(l1);
     l2 = normalizeTableLayoutModel(l2);
-    return isDeepEqual(l1, l2);
+    const res = isDeepEqual(l1, l2);
+    if (!res) {
+        logChanges(l1, l2);
+    }
+    return res;
 }
 export function isPivotLayoutEqual(l1, l2) {
     l1 = normalizePivotLayoutModel(l1);
     l2 = normalizePivotLayoutModel(l2);
-    return isDeepEqual(l1, l2);
+    const res = isDeepEqual(l1, l2);
+    if (!res) {
+        logChanges(l1, l2);
+    }
+    return res;
 }
 export function isLayoutEqual(l1, l2) {
     if (isPivotLayoutModel(l1) != isPivotLayoutModel(l2)) {

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

@@ -0,0 +1 @@
+export declare function isPivotColumnTotal(colId: string): boolean;

package/src/layout-manager/src/{isPivotGroupTotalColumn.js → isPivotColumnTotal.js}

@@ -1,4 +1,4 @@
-export function isPivotGroupTotalColumn(colId) {
+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/isPivotGrandTotal.d.ts

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

package/src/layout-manager/src/{isPivotGrandTotalColumn.js → isPivotGrandTotal.js}

@@ -1,3 +1,3 @@
-export function isPivotGrandTotalColumn(colDef) {
+export function isPivotGrandTotal(colDef) {
     return colDef?.colId?.startsWith('PivotRowTotal_pivot_');
 }

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

@@ -25,6 +25,14 @@ export function normalizeTableLayoutModel(layout, options) {
     if (!layout.RowGroupedColumns) {
         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;
+    }
     const ColumnOrderSet = new Set(layout.TableColumns);
     if (layout.RowGroupedColumns && layout.RowGroupedColumns.length && layout.TableColumns) {
         // the layout.TableColumns might not include the group columns
@@ -131,6 +139,22 @@ export function normalizePivotLayoutModel(layout) {
             RowGroupDisplay: 'always-collapsed',
         };
     }
+    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;
+    }
     return layout;
 }
 export function normalizeLayoutModel(layout, options) {

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

@@ -53,7 +53,7 @@ export function simplifyTableLayoutModel(layout) {
         });
         layout.RowGroupDisplayType = displayType;
     }
-    if (!layout.GrandTotalRow) {
+    if (layout.GrandTotalRow === undefined) {
         delete layout.GrandTotalRow;
     }
     return layout;
@@ -75,6 +75,15 @@ export function simplifyPivotLayoutModel(layout) {
     if (!layout.PivotGroupedColumns && layout.RowGroupValues) {
         delete layout.RowGroupValues;
     }
+    if (layout.GrandTotalRow === undefined) {
+        delete layout.GrandTotalRow;
+    }
+    if (layout.PivotColumnTotal === undefined) {
+        delete layout.PivotColumnTotal;
+    }
+    if (layout.PivotGrandTotal === undefined) {
+        delete layout.PivotGrandTotal;
+    }
     return layout;
 }
 export function simplifyLayoutModel(layout) {