@adaptabletools/adaptable 20.0.13 → 20.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "20.0.13",
+  "version": "20.1.1",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -63,7 +63,7 @@
     "uuid": "9.0.1"
   },
   "peerDependencies": {
-    "ag-grid-enterprise": ">=33.0.0"
+    "ag-grid-enterprise": ">=33.2.0"
   },
   "publishTimestamp": 0,
   "type": "module",

package/src/AdaptableOptions/ColumnOptions.d.ts

@@ -38,7 +38,7 @@ export interface ColumnOptions {
 /**
  * Common properties for Column Header Context
  */
-export type BaseColumnHeaderContext = {
+export interface BaseColumnHeaderContext extends BaseContext {
     /**
      * The default header name for the column
      */
@@ -55,8 +55,163 @@ export type BaseColumnHeaderContext = {
      * The current Layout
      */
     currentLayout: Layout;
-} & BaseContext;
-export type ColumnHeaderContext = BaseColumnHeaderContext & ({
+}
+export interface AutoGroupColumnHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Auto-generated Group Column when GroupDisplayType is `single` column
+     */
+    columnType: 'autoGroupColumn';
+    /**
+     * Technical ID of the Column
+     */
+    columnId: string;
+    /**
+     * IDs of the Columns that are grouped
+     */
+    groupedColumnIds: string[];
+}
+export interface RowGroupColumnHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Group Columns - see `TableLayout.RowGroupedColumns` or `PivotLayout.PivotGroupedColumns`
+     */
+    columnType: 'groupColumn';
+    /**
+     * Technical ID of the Column
+     */
+    columnId: string;
+    /**
+     * ID of the grouped Column
+     */
+    groupColumnId: string;
+}
+export interface TableColumnHeaderContext extends BaseColumnHeaderContext {
+    /**
+     *  Table Column - see `TableLayout.TableColumns`
+     */
+    columnType: 'tableColumn';
+    /**
+     * Technical ID of the Column
+     */
+    columnId: string;
+    /**
+     * Optional Aggregation function of the Column - see `TableLayout.TableAggregationColumns`
+     */
+    aggregation?: string;
+}
+export interface TableColumnGroupHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Column Group - see https://www.ag-grid.com/javascript-data-grid/column-groups/
+     */
+    columnType: 'tableColumnGroup';
+    /**
+     * Technical ID of the Column Group - see `ColGroupDef.groupId`
+     */
+    groupId: string;
+    /**
+     * IDs of the Column Group children - see `ColGroupDef.children`
+     */
+    childrenColumnIds: string[];
+    /**
+     * State of the Column Group
+     */
+    state: 'expanded' | 'collapsed';
+}
+export interface PivotColumnGroupHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Pivot Column - see `PivotLayout.PivotColumns`
+     */
+    columnType: 'pivotColumnGroup';
+    /**
+     * Technical ID of the generated Column Group
+     */
+    groupId: string;
+    /**
+     * Pivot Keys for the current Column Group
+     */
+    pivotKeys: string[];
+    /**
+     * State of the Column Group
+     */
+    state: 'expanded' | 'collapsed';
+}
+export interface PivotAggregationColumnHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Pivot Aggregation Column - see `PivotLayout.PivotAggregationColumns`
+     */
+    columnType: 'pivotAggregationColumn';
+    /**
+     * Technical ID of the generated Column
+     */
+    columnId: string;
+    /**
+     * Current Pivot Keys
+     */
+    pivotKeys: string[];
+    /**
+     * ID of the Aggregated Column - see `PivotLayout.PivotAggregationColumns`
+     */
+    aggregatedColumnId: string;
+    /**
+     *  Aggregation function of the Column - see `PivotLayout.PivotAggregationColumns.AggregationColumnValue`
+     */
+    aggregation: string;
+}
+export interface PivotGrandTotalHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Pivot Grand Total - see `PivotLayout.PivotGrandTotal`
+     */
+    columnType: 'pivotGrandTotal';
+    /**
+     * ID of the Aggregated Column - see `PivotLayout.PivotAggregationColumns`
+     */
+    aggregatedColumnId: string;
+    /**
+     *  Aggregation function of the Column - see `PivotLayout.PivotAggregationColumns.AggregationColumnValue`
+     */
+    aggregation: string;
+}
+export interface PivotColumnTotalHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Pivot Column Total - see `PivotLayout.PivotColumnTotal`
+     */
+    columnType: 'pivotColumnTotal';
+    /**
+     * Current Pivot Keys
+     */
+    pivotKey: string;
+    /**
+     * ID of the Pivot Column - see `PivotLayout.PivotColumns`
+     */
+    pivotColumnId: string;
+    /**
+     *  Aggregation function of the Column - see `PivotLayout.PivotAggregationColumns.AggregationColumnValue`
+     */
+    aggregation: string;
+}
+export interface PivotAggregationTotalHeaderContext extends BaseColumnHeaderContext {
+    /**
+     * Pivot Aggregation Total Column - see `PivotLayout.PivotAggregationColumns.TotalColumn`
+     */
+    columnType: 'pivotAggregationTotal';
+    /**
+     * ID of the Aggregated Column - see `PivotLayout.PivotAggregationColumns`
+     */
+    aggregatedColumnId: string;
+    /**
+     *  Aggregation function of the Column - see `PivotLayout.PivotAggregationColumns.AggregationColumnValue`
+     */
+    aggregation: string;
+    /**
+     * ID of the Pivot Column - see `PivotLayout.PivotColumns`
+     */
+    pivotColumnId: string;
+    /**
+     * Current Pivot Keys
+     */
+    pivotKey: string;
+}
+export type ColumnHeaderContext = TableColumnHeaderContext | TableColumnGroupHeaderContext | AutoGroupColumnHeaderContext | RowGroupColumnHeaderContext | PivotColumnGroupHeaderContext | PivotAggregationColumnHeaderContext | PivotGrandTotalHeaderContext | PivotColumnTotalHeaderContext | PivotAggregationTotalHeaderContext;
+export type ColumnHeaderContextOld = BaseColumnHeaderContext & ({
     /**
      * Auto-generated Group Column when GroupDisplayType is `single` column
      */

package/src/Api/Implementation/ExportApiImpl.js

@@ -159,8 +159,8 @@ export class ExportApiImpl extends ApiBase {
                 destination,
                 showProgressIndicator: true,
             });
-            if (destination === 'Download' &&
-                (format === 'Excel' || format === 'VisualExcel' || format === 'Csv')) {
+            if (!exportedReport) {
+                // for destination 'Download' and format 'Excel', 'VisualExcel' or 'Csv', AG Grid handles the download as well
                 return;
             }
             this.internalApi.sendReportToDestination(exportedReport, report, format, destination);

package/src/Api/Implementation/LayoutApiImpl.js

@@ -41,7 +41,7 @@ export class LayoutApiImpl extends ApiBase {
         if (isPivotLayout(layout)) {
             return [];
         }
-        return layout.TableColumns.filter((colId) => layout.ColumnVisibility?.[colId] !== false);
+        return layout.TableColumns.filter((colId) => !layout.ColumnVisibility || layout.ColumnVisibility?.[colId] !== false);
     }
     getCurrentRowGroupsColumnIds() {
         const layout = this.getCurrentLayout();

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

@@ -4,6 +4,7 @@ import { Report, ReportData, ReportFormatType, ReportNameType, SystemReportName
 import { CsvCell, ExcelCell, ExcelDataType, IRowNode } from 'ag-grid-enterprise';
 import { AdaptableColumn, AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
 import { BaseExportContext, DataFormatType, ExportDestinationType, ExportResultData, ProcessExportContext } from '../../AdaptableOptions/ExportOptions';
+import { ExportProcessData } from '../../agGrid/AgGridExportAdapter';
 export declare class ExportInternalApi extends ApiBase {
     /**
      * Value Items for Report Name Selection
@@ -35,6 +36,7 @@ export declare class ExportInternalApi extends ApiBase {
     createCellExcel(cellContent: any, cellType: ExcelDataType): ExcelCell;
     createCellHeader(cellContent: any): ExcelCell;
     buildProcessExportContext(report: Report, format: ReportFormatType, destination: ExportDestinationType): ProcessExportContext;
+    exportAllDataInPivotMode(exportProcessData: ExportProcessData): ExportResultData | null;
     private buildExcelConverter;
     private buildCsvConverter;
     private executeGridExport;

package/src/Api/Internal/ExportInternalApi.js

@@ -387,6 +387,42 @@ export class ExportInternalApi extends ApiBase {
                 .filter(Boolean),
         };
     }
+    exportAllDataInPivotMode(exportProcessData) {
+        const { exportContext, exportParams } = exportProcessData;
+        const exportedColumns = this.getColumnApi()
+            .getExportableColumns()
+            .filter((column) => !column.isGeneratedPivotResultColumn);
+        const exportedRowData = this.getGridApi().getGridData();
+        const reportData = {
+            columns: exportedColumns,
+            rows: exportedRowData,
+        };
+        const exportFormat = exportContext.format;
+        if (exportFormat === 'JSON') {
+            return {
+                data: reportData,
+                type: 'json',
+            };
+        }
+        if (exportFormat === 'CSV') {
+            const csvExportConverter = this.buildCsvConverter(exportContext.report.Name, exportFormat, exportContext.destination);
+            const csvData = csvExportConverter(reportData);
+            return {
+                data: csvData,
+                type: 'csv',
+            };
+        }
+        // theoretically 'VisualExcel' is not a valid export format for this function and should be suppressed from UI
+        // but just in case, we handle it here and return a "raw", unstyled Excel file
+        if (exportFormat === 'Excel' || exportFormat === 'VisualExcel') {
+            const excelExportConverter = this.buildExcelConverter(exportContext.report.Name, exportFormat, exportContext.destination);
+            const excelData = excelExportConverter(reportData);
+            return {
+                data: excelData,
+                type: 'excel',
+            };
+        }
+    }
     buildExcelConverter(reportName, reportFormat, exportDestination) {
         return (reportData) => {
             return this.executeGridExport(reportData, reportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsExcel({ ...exportParams }));
@@ -413,6 +449,7 @@ export class ExportInternalApi extends ApiBase {
                 rowData: reportData.rows,
                 theme: this.getAgGridApi().getGridOption('theme'),
                 dataTypeDefinitions: this.getAgGridApi().getGridOption('dataTypeDefinitions'),
+                columnTypes: this.getAgGridApi().getGridOption('columnTypes'),
             };
             const gridParams = {
                 modules: this.getAdaptableApi()

package/src/Strategy/Utilities/FormatColumn/getFormatColumnSettingsViewItems.d.ts

@@ -1,4 +1,4 @@
-import { FormatColumn } from '../../../../types';
+import { FormatColumn } from '../../../AdaptableState/FormatColumnState';
 export declare const getFormatColumnSettingsViewItems: (formatColumn: FormatColumn) => {
     name: string;
     values: string[];

package/src/Strategy/Utilities/FormatColumn/getFormatColumnSettingsViewItems.js

@@ -1,12 +1,21 @@
 export const getFormatColumnSettingsViewItems = (formatColumn) => {
-    const values = [
-        `Cell alignment: ${formatColumn.CellAlignment ?? 'default'}`,
-        `Data Rows: ${formatColumn.RowScope?.ExcludeDataRows ? 'Yes' : 'No'}`,
-        `Group Rows: ${formatColumn.RowScope?.ExcludeGroupRows ? 'Yes' : 'No'}`,
-        `Row Summaries: ${formatColumn.RowScope?.ExcludeSummaryRows ? 'Yes' : 'No'}`,
-    ].filter(Boolean);
+    let values = [];
+    if (formatColumn.CellAlignment) {
+        values.push(`Cell Alignment: ${formatColumn.CellAlignment}`);
+    }
+    if (formatColumn.RowScope) {
+        if (formatColumn.RowScope.ExcludeDataRows) {
+            values.push('Exclude Data Rows');
+        }
+        if (formatColumn.RowScope.ExcludeGroupRows) {
+            values.push('Exclude Group Rows');
+        }
+        if (formatColumn.RowScope.ExcludeSummaryRows) {
+            values.push('Exclude Summary Rows');
+        }
+    }
     return {
         name: 'Settings',
-        values,
+        values: values.filter(Boolean),
     };
 };

package/src/View/Export/ReportFormatSelector.js

@@ -16,7 +16,5 @@ export const ReportFormatSelector = (props) => {
     });
     const elementType = props.viewType === 'Toolbar' ? 'DashboardToolbar' : 'ToolPanel';
     return (React.createElement(Flex, { "data-name": "report-format-selector", flex: 1, minWidth: 140 },
-        React.createElement(Select, { 
-            // style={{ width: '100%' }}
-            size: size, placeholder: SELECT_REPORT_FORMAT_STRING, disabled: !allFormats.length || reportName == undefined, className: `ab-${elementType}__Export__format-select`, options: formatItems, onChange: (format) => onReportFormatSelected(format), value: reportFormat, isClearable: true })));
+        React.createElement(Select, { style: { width: '100%' }, size: size, placeholder: SELECT_REPORT_FORMAT_STRING, disabled: !allFormats.length || reportName == undefined, className: `ab-${elementType}__Export__format-select`, options: formatItems, onChange: (format) => onReportFormatSelected(format), value: reportFormat, isClearable: true })));
 };

package/src/View/Export/ReportNameSelector.js

@@ -15,6 +15,6 @@ export const ReportNameSelector = (props) => {
         };
     });
     const elementType = props.viewType === 'Toolbar' ? 'DashboardToolbar' : 'ToolPanel';
-    return (React.createElement(Flex, { flex: 1, minWidth: props.viewType !== 'StatusBar' ? 160 : undefined },
+    return (React.createElement(Flex, { "data-name": "report-name-selector", flex: 1, minWidth: 160 },
         React.createElement(Select, { style: { width: '100%' }, size: size, "data-name": "report-name-selector", placeholder: SELECT_REPORT_STRING, disabled: !allReportNames.length, className: `ab-${elementType}__Export__report-select`, options: reportItems, onChange: (report) => onReportNameSelected(report), value: reportName, isClearable: true })));
 };

package/src/View/StyledColumn/Wizard/StyledColumnSparklineSettingsSection.js

@@ -232,54 +232,56 @@ const SparklineAxisOptions = ({ options, onChange, }) => {
 };
 const SparklineTooltipOptions = ({ options, onChange, }) => {
     const sparklineOptions = options;
-    const handleChange = (key, value) => {
-        onChange({ ...options, [key]: value });
+    const isTooltipEnabled = sparklineOptions.tooltip?.enabled ?? false;
+    const handleChange = (property, value) => {
+        onChange({
+            ...options,
+            tooltip: {
+                ...options.tooltip,
+                [property]: value,
+            },
+        });
     };
-    const isTooltipEnabled = sparklineOptions.tooltip?.enabled;
-    const positionTypes = [
+    const anchorToOptions = [
         { value: 'pointer', label: 'Pointer' },
         { value: 'node', label: 'Node' },
+        { value: 'chart', label: 'Chart' },
+    ];
+    const placementOptions = [
         { value: 'top', label: 'Top' },
         { value: 'right', label: 'Right' },
         { value: 'bottom', label: 'Bottom' },
         { value: 'left', label: 'Left' },
-        { value: 'top-left', label: 'Top Left' },
         { value: 'top-right', label: 'Top Right' },
         { value: 'bottom-right', label: 'Bottom Right' },
         { value: 'bottom-left', label: 'Bottom Left' },
-    ];
-    const interactionRanges = [
-        { value: 'exact', label: 'Exact' },
-        { value: 'nearest', label: 'Nearest' },
+        { value: 'top-left', label: 'Top Left' },
+        { value: 'center', label: 'Center' },
     ];
     return (React.createElement(FormLayout, null,
-        React.createElement(FormRow, { label: "Enabled" },
-            React.createElement(CheckBox, { checked: sparklineOptions.tooltip?.enabled, onChange: (enabled) => handleChange('tooltip', { ...sparklineOptions.tooltip, enabled }) })),
-        React.createElement(FormRow, { label: "Show Arrow" },
-            React.createElement(CheckBox, { disabled: !isTooltipEnabled, checked: sparklineOptions.tooltip?.showArrow, onChange: (showArrow) => handleChange('tooltip', { ...sparklineOptions.tooltip, showArrow }) })),
-        React.createElement(FormRow, { label: "Interaction Enabled" },
-            React.createElement(CheckBox, { disabled: !isTooltipEnabled, checked: sparklineOptions.tooltip?.interaction?.enabled, onChange: (enabled) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    interaction: { enabled },
-                }) })),
-        React.createElement(FormRow, { label: "Range" },
+        React.createElement(FormRow, { label: "Show Tooltip" },
+            React.createElement(CheckBox, { checked: isTooltipEnabled, onChange: (enabled) => handleChange('enabled', enabled) })),
+        React.createElement(FormRow, { label: "Anchor To" },
             React.createElement(Box, { maxWidth: 160 },
-                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.range ?? 'nearest', onChange: (range) => handleChange('tooltip', { ...sparklineOptions.tooltip, range }), options: interactionRanges }))),
-        React.createElement(FormRow, { label: "Position Type" },
+                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.anchorTo, onChange: (value) => handleChange('position', {
+                        ...sparklineOptions.tooltip?.position,
+                        anchorTo: value,
+                    }), options: anchorToOptions }))),
+        React.createElement(FormRow, { label: "Placement" },
             React.createElement(Box, { maxWidth: 160 },
-                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.type ?? 'pointer', onChange: (type) => handleChange('tooltip', {
-                        ...sparklineOptions.tooltip,
-                        position: { ...sparklineOptions.tooltip?.position, type },
-                    }), options: positionTypes }))),
+                React.createElement(Select, { disabled: !isTooltipEnabled, value: sparklineOptions.tooltip?.position?.placement, onChange: (value) => handleChange('position', {
+                        ...sparklineOptions.tooltip?.position,
+                        placement: value,
+                    }), options: placementOptions }))),
         React.createElement(FormRow, { label: "Position Offset X" },
-            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The horizontal offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.xOffset ?? '', onChange: (e) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    position: { ...sparklineOptions.tooltip?.position, xOffset: Number(e.target.value) },
+            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The horizontal offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.xOffset ?? '', onChange: (e) => handleChange('position', {
+                    ...sparklineOptions.tooltip?.position,
+                    xOffset: Number(e.target.value),
                 }) })),
         React.createElement(FormRow, { label: "Position Offset Y" },
-            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The vertical offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.yOffset ?? '', onChange: (e) => handleChange('tooltip', {
-                    ...sparklineOptions.tooltip,
-                    position: { ...sparklineOptions.tooltip?.position, yOffset: Number(e.target.value) },
+            React.createElement(AdaptableInput, { disabled: !isTooltipEnabled, title: "The vertical offset in pixels for the position of the tooltip.", type: "number", value: sparklineOptions.tooltip?.position?.yOffset ?? '', onChange: (e) => handleChange('position', {
+                    ...sparklineOptions.tooltip?.position,
+                    yOffset: Number(e.target.value),
                 }) }))));
 };
 const SparklineMarkerOptions = ({ options, onChange }) => {

package/src/agGrid/AgGridAdapter.js

@@ -1,6 +1,6 @@
 import { ColumnApiModule, } from 'ag-grid-enterprise';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
-import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME } from '../Utilities/Constants/GeneralConstants';
+import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_COLUMN, } from '../Utilities/Constants/GeneralConstants';
 import { createUuid } from '../AdaptableState/Uuid';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -453,6 +453,10 @@ export class AgGridAdapter {
             this.logger.warn(`Column is undefined, returning 'text' for Type`);
             return 'text';
         }
+        if (agColumn.getId() === AG_GRID_GROUPED_COLUMN ||
+            agColumn.getId() === AG_GRID_SELECTION_COLUMN) {
+            return 'unknown';
+        }
         const colDefType = [].concat(agColumn.getColDef()?.type || []).filter(Boolean);
         const skippedSpecialCols = ['actionColumn', 'fdc3Column'];
         if (skippedSpecialCols.some((specialColType) => colDefType.includes(specialColType))) {

package/src/agGrid/AgGridExportAdapter.js

@@ -50,6 +50,7 @@ export class AgGridExportAdapter {
     }
     async exportData(config) {
         const { report, format, showProgressIndicator } = config;
+        let excelStylesWerePatched = false;
         try {
             if (showProgressIndicator) {
                 this.adaptableApi.userInterfaceApi.showProgressIndicator({
@@ -60,11 +61,19 @@ export class AgGridExportAdapter {
                 await waitForTimeout(16);
             }
             this.adaptableApi.exportApi.internalApi.setExportInProgress(config.report.Name, config.format, config.destination);
-            const { exportContext, exportParams } = this.buildExportProcessData(config);
+            const exportProcessData = this.buildExportProcessData(config);
+            const { exportContext, exportParams } = exportProcessData;
+            if (this.adaptableApi.layoutApi.isCurrentLayoutPivot() &&
+                config.report.ReportRowScope === 'AllRows') {
+                // if in pivot mode but the user wants to export all rows (aka the table row data), we cannot use AG Grids row model
+                // we have to use an intermediary transient AG Grid instance
+                return this.adaptableApi.exportApi.internalApi.exportAllDataInPivotMode(exportProcessData);
+            }
             if (exportContext.isVisualExcelReport) {
                 // FIXME AFL patch styles only for exported columns!
                 // or even better, only cells
                 this.patchExcelStyles();
+                excelStylesWerePatched = true;
             }
             // 1. easiest case, we download the file using AG Grid
             // these methods will automatically handle the file download
@@ -106,7 +115,7 @@ export class AgGridExportAdapter {
              * Cleanup export process
              */
             this.adaptableApi.exportApi.internalApi.setExportComplete();
-            if (format === 'VisualExcel') {
+            if (excelStylesWerePatched) {
                 this.resetExcelStyles();
             }
             if (showProgressIndicator) {
@@ -119,9 +128,6 @@ export class AgGridExportAdapter {
      */
     buildExportProcessData(config) {
         const exportContext = this.buildExportProcessContext(config);
-        if (exportContext.isVisualExcelReport) {
-            this.patchExcelStyles();
-        }
         const exportParams = this.buildExportParams(exportContext);
         exportContext.exportedColumnIds = exportParams.columnKeys;
         return {

package/src/env.js

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

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

@@ -32,7 +32,6 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     private globalAgGridEventListener;
     private columnDefsChanged;
     private indexColumns;
-    private getColDefById;
     private onGridLayoutChanged;
     private triggerGridLayoutChange;
     onChange(fn: (layout: TableLayoutModel | PivotLayoutModel) => void): () => void;

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

@@ -205,9 +205,6 @@ export class LayoutManager extends LMEmitter {
         };
         colDefs.forEach(iteration);
     }
-    getColDefById(colId) {
-        return this.idsToColDefs[colId] ?? null;
-    }
     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

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

@@ -37,15 +37,24 @@ export const logChanges = (l1, l2, log) => {
 export function isTableLayoutEqual(l1, l2) {
     l1 = normalizeTableLayoutModel(l1);
     l2 = normalizeTableLayoutModel(l2);
+    clearIgnoredProperties(l1);
+    clearIgnoredProperties(l2);
     const res = isDeepEqual(l1, l2);
     if (!res) {
         logChanges(l1, l2);
     }
     return res;
 }
+//#clearIgnoredProperties
+function clearIgnoredProperties(layout) {
+    delete layout.GridFilter;
+    delete layout.ColumnFilters;
+}
 export function isPivotLayoutEqual(l1, l2) {
     l1 = normalizePivotLayoutModel(l1);
     l2 = normalizePivotLayoutModel(l2);
+    clearIgnoredProperties(l1);
+    clearIgnoredProperties(l2);
     const res = isDeepEqual(l1, l2);
     if (!res) {
         logChanges(l1, l2);

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

@@ -1501,6 +1501,22 @@ export declare const ADAPTABLE_METAMODEL: {
         kind: string;
         desc: string;
     };
+    BaseColumnHeaderContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            ref: string;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            ref?: undefined;
+        })[];
+    };
     BaseContext: {
         name: string;
         kind: string;
@@ -4413,6 +4429,11 @@ export declare const ADAPTABLE_METAMODEL: {
             ref: string;
         })[];
     };
+    PivotTotalPosition: {
+        name: string;
+        kind: string;
+        desc: string;
+    };
     PlusMinusNudge: {
         name: string;
         kind: string;