@adaptabletools/adaptable 20.0.0-canary.2 → 20.0.0-canary.20

package/src/Api/Internal/ExportInternalApi.js

@@ -1,15 +1,12 @@
-import groupBy from 'lodash/groupBy';
 import { ApiBase } from '../Implementation/ApiBase';
+import { createGrid, } from 'ag-grid-enterprise';
 import { createUuid } from '../../PredefinedConfig/Uuid';
 import { ALL_DATA_REPORT, CURRENT_LAYOUT_REPORT, SELECTED_DATA_REPORT, SYSTEM_EXPORT_DESTINATIONS, SYSTEM_REPORT_NAMES, } from '../../Utilities/Constants/GeneralConstants';
-import { ExportModuleId } from '../../Utilities/Constants/ModuleConstants';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import FormatHelper, { DateFormatter } from '../../Utilities/Helpers/FormatHelper';
 import Helper from '../../Utilities/Helpers/Helper';
 import * as PopupRedux from '../../Redux/ActionsReducers/PopupRedux';
 import { SystemExportBegin, SystemExportEnd } from '../../Redux/ActionsReducers/InternalRedux';
-import { errorOnce } from '../../agGrid/AdaptableLogger';
 export class ExportInternalApi extends ApiBase {
     /**
      * Value Items for Report Name Selection
@@ -113,7 +110,7 @@ export class ExportInternalApi extends ApiBase {
             // format is customized based on column data type
             switch (columnDataType) {
                 case 'text':
-                    return dataFormatDataType.string;
+                    return dataFormatDataType.text;
                 case 'number':
                     return dataFormatDataType.number;
                 case 'date':
@@ -211,7 +208,6 @@ export class ExportInternalApi extends ApiBase {
             return `[${report.Name}]`;
         }
         else {
-            // FIXME AFL: maybe fihnd a better description?
             switch (report.ReportRowScope) {
                 case 'AllRows':
                     return '[All Rows]';
@@ -224,138 +220,12 @@ export class ExportInternalApi extends ApiBase {
             }
         }
     }
-    getReportDataColumns(report, includePrimaryKey = false) {
-        let reportColumns = [];
-        let gridColumns = this.getAdaptableApi().columnApi.getExportableColumns();
-        if (this.getAdaptableApi().exportApi.isExternalReport(report)) {
-            return reportColumns;
-        }
-        // first get the cols depending on the Column Scope
-        switch (report.ReportColumnScope) {
-            case 'AllColumns':
-                reportColumns = gridColumns;
-                break;
-            case 'VisibleColumns':
-                reportColumns = gridColumns.filter((c) => c.visible);
-                break;
-            case 'SelectedColumns':
-                // we extract the selected columns from the grid columns to preserve the grid column order
-                const selectedColumnIds = this.getAdaptableApi()
-                    .gridApi.getSelectedCellInfo()
-                    .columns.map((column) => column.columnId);
-                reportColumns = gridColumns.filter((gridColumn) => selectedColumnIds.includes(gridColumn.columnId));
-                break;
-            case 'ScopeColumns':
-                if ('ColumnIds' in report.Scope) {
-                    reportColumns = report.Scope.ColumnIds.map((columnId) => this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId)).filter((c) => c);
-                }
-                else {
-                    reportColumns = this.getAdaptableApi().columnScopeApi.getColumnsInScope(report.Scope);
-                }
-                break;
-        }
-        if (includePrimaryKey) {
-            const pkColumn = reportColumns.find((column) => column.columnId === this.getAdaptableApi().optionsApi.getPrimaryKey());
-            // TODO simplify after we fix the IsPrimaryKey bug
-            // const pkColumn = reportColumns.find(column => column.IsPrimaryKey);
-            if (!pkColumn && !!this.getAdaptableApi().columnApi.getPrimaryKeyColumn()) {
-                reportColumns.push(this.getAdaptableApi().columnApi.getPrimaryKeyColumn());
-            }
-        }
-        return reportColumns;
-    }
-    getReportDataRows(report, columns, includePrimaryKey) {
-        if (ArrayExtensions.IsNullOrEmpty(columns)) {
-            return [];
-        }
-        const columnIds = columns.map((column) => column.columnId);
-        const resultRowData = [];
-        switch (report.ReportRowScope) {
-            case 'AllRows':
-                this.getAdaptableInternalApi().forAllRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
-                });
-                break;
-            case 'VisibleRows':
-                this.getAdaptableInternalApi().forAllVisibleRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
-                });
-                break;
-            case 'ExpressionRows':
-                this.getAdaptableInternalApi().forAllRowNodesDo((rowNode) => {
-                    try {
-                        if (this.getAdaptableApi()
-                            .internalApi.getQueryLanguageService()
-                            .evaluateBooleanExpression(report.Query?.BooleanExpression, ExportModuleId, rowNode)) {
-                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
-                        }
-                    }
-                    catch (error) {
-                        errorOnce(error.message);
-                    }
-                });
-                break;
-            case 'SelectedRows':
-                // CellSelection
-                const selectedCellInfo = this.getAdaptableApi().gridApi.getSelectedCellInfo();
-                const { gridCells: GridCells } = selectedCellInfo;
-                let selectedCellsByPrimaryKey = groupBy(GridCells, 'primaryKeyValue');
-                // we iterate over all visibleRowNodes to preserve the current order
-                this.getAdaptableInternalApi().forAllVisibleRowNodesDo((rowNode) => {
-                    const rowPrimaryKeyValue = this.getAdaptableApi().gridApi.getPrimaryKeyValueForRowNode(rowNode);
-                    const selectedRowCells = selectedCellsByPrimaryKey[rowPrimaryKeyValue];
-                    if (selectedRowCells) {
-                        const selectedRowColumnIds = selectedRowCells.map((rowCell) => rowCell.column.columnId);
-                        const selectedColumnIds = columnIds.filter((columnId) => selectedRowColumnIds.includes(columnId));
-                        const row = this.getRowObjectForColumnIds(rowNode, selectedColumnIds, report.Name);
-                        if (includePrimaryKey) {
-                            row[this.getAdaptableApi().optionsApi.getPrimaryKey()] = rowPrimaryKeyValue;
-                        }
-                        resultRowData.push(row);
-                    }
-                });
-                // Row Selection
-                const selectedRowInfo = this.getAdaptableApi().gridApi.getSelectedRowInfo();
-                const selectedGridRowPrimaryKeys = selectedRowInfo?.gridRows
-                    ?.filter((gr) => gr.rowInfo.isGroup == false)
-                    .map((gridRow) => gridRow.primaryKeyValue) ?? [];
-                if (selectedGridRowPrimaryKeys.length) {
-                    this.getAdaptableInternalApi().forAllRowNodesDo((rowNode) => {
-                        const rowPrimaryKeyValue = this.getAdaptableApi().gridApi.getPrimaryKeyValueForRowNode(rowNode);
-                        if (selectedGridRowPrimaryKeys.includes(rowPrimaryKeyValue)) {
-                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds, report.Name));
-                        }
-                    });
-                }
-                break;
-        }
-        return resultRowData;
-    }
-    getReportData(report, includePrimaryKey = false) {
-        if (this.getAdaptableApi().exportApi.isExternalReport(report)) {
-            return this.getAdaptableApi().exportApi.runExternalReport(report.Name);
-        }
-        const columns = this.getReportDataColumns(report, includePrimaryKey);
-        const rows = this.getReportDataRows(report, columns, includePrimaryKey);
-        return { columns, rows };
-    }
-    getReportDataAsArray(report, includePrimaryKey = false) {
-        const reportData = this.getReportData(report, includePrimaryKey);
-        return this.convertReportDataToArray(reportData);
-    }
     convertReportDataToArray(reportData) {
         return [
             reportData.columns.map((column) => column.friendlyName),
-            ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.columnId])),
+            ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.field ?? column.columnId])),
         ];
     }
-    getRowObjectForColumnIds(rowNode, columnIds, reportName) {
-        return columnIds.reduce((result, columnId) => {
-            // FIXME AFL if this method remains, 'false' should be replaced with dynamic value
-            result[columnId] = this.getCellExportValueFromRowNode(rowNode, columnId, false);
-            return result;
-        }, {});
-    }
     publishLiveLiveDataChangedEvent(reportDestination, liveDataTrigger, liveReport) {
         const liveDataChangedInfo = {
             ...this.getAdaptableInternalApi().buildBaseContext(),
@@ -429,9 +299,8 @@ export class ExportInternalApi extends ApiBase {
             this.sendReportToCustomDestination(reportResult, report, format, destination);
         }
         if (destination === 'Download') {
-            if (format === 'Excel' || format === 'VisualExcel') {
-                this.logWarn(`Download of Excel files should already be handed by internal APIs, something went wrong`);
-                return;
+            if (reportResult.type === 'excel') {
+                Helper.createDownloadedFile(reportResult.data, this.getReportFileName(report.Name, format, destination), 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
             }
             if (reportResult.type === 'csv') {
                 Helper.createDownloadedFile(reportResult.data, this.getReportFileName(report.Name, format, destination), 'text/csv;encoding:utf-8');
@@ -490,4 +359,104 @@ export class ExportInternalApi extends ApiBase {
             exportDestination,
         };
     }
+    createCellCsv(cellContent) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+            },
+        };
+    }
+    createCellExcel(cellContent, cellType) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+                type: cellType,
+            },
+        };
+    }
+    createCellHeader(cellContent) {
+        return {
+            data: {
+                value: cellContent != undefined ? String(cellContent) : null,
+                type: 'String',
+            },
+        };
+    }
+    getExternalReportData(externalReportName, reportFormat, exportDestination) {
+        const externalReport = this.getExportApi()
+            .getExternalReports()
+            ?.find((cr) => cr.name == externalReportName);
+        if (!externalReport) {
+            this.logWarn(`External Report '${externalReportName}' not found!`);
+            return undefined;
+        }
+        return externalReport.onExport({
+            ...this.buildBaseExportContext(externalReportName, reportFormat, exportDestination),
+            convertToExcel: this.buildExcelConverter(externalReportName, reportFormat, exportDestination),
+            convertToCsv: this.buildCsvConverter(externalReportName, reportFormat, exportDestination),
+            getGridReportColumns: this.buildGridReportColumns(),
+        });
+    }
+    buildGridReportColumns() {
+        return () => this.getAdaptableApi().columnApi.getColumns();
+    }
+    buildExcelConverter(externalReportName, reportFormat, exportDestination) {
+        return (reportData) => {
+            return this.executeGridExport(reportData, externalReportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsExcel({ ...exportParams }));
+        };
+    }
+    buildCsvConverter(externalReportName, reportFormat, exportDestination) {
+        return (reportData) => {
+            const csvParams = this.buildCsvExportParams(externalReportName, reportFormat, exportDestination);
+            return this.executeGridExport(reportData, externalReportName, reportFormat, exportDestination, (gridApi, exportParams) => gridApi.getDataAsCsv({ ...exportParams, ...csvParams }));
+        };
+    }
+    executeGridExport(reportData, externalReportName, reportFormat, exportDestination, exportFn) {
+        const htmlDivElement = document.createElement('div');
+        let ephemeralGridApi = null;
+        try {
+            const columnDefs = reportData.columns.map((col) => ({
+                colId: col.columnId,
+                field: col.field ?? col.columnId,
+                headerName: col.friendlyName ?? col.columnId,
+                type: col.dataType ?? 'text',
+            }));
+            const gridOptions = { columnDefs, rowData: reportData.rows };
+            const gridParams = {
+                modules: this.getAdaptableApi()
+                    .internalApi.getAdaptableInstance()
+                    .getAgGridRegisteredModules(),
+            };
+            htmlDivElement.style.display = 'none';
+            document.body.appendChild(htmlDivElement);
+            ephemeralGridApi = createGrid(htmlDivElement, gridOptions, gridParams);
+            const exportParams = {
+                fileName: this.getReportFileName(externalReportName, reportFormat, exportDestination),
+                allColumns: true,
+                exportedRows: 'all',
+            };
+            return exportFn(ephemeralGridApi, exportParams);
+        }
+        catch (error) {
+            this.logWarn('Failed to export data:', error);
+            return null;
+        }
+        finally {
+            if (ephemeralGridApi) {
+                ephemeralGridApi.destroy();
+            }
+            if (htmlDivElement?.parentNode) {
+                document.body.removeChild(htmlDivElement);
+            }
+        }
+    }
+    buildCsvExportParams(externalReportName, reportFormat, exportDestination) {
+        const exportOptions = this.getAdaptableApi().optionsApi.getExportOptions();
+        const csvSeparator = typeof exportOptions.csvSeparator === 'function'
+            ? exportOptions.csvSeparator(this.buildBaseExportContext(externalReportName, reportFormat, exportDestination))
+            : exportOptions.csvSeparator;
+        return {
+            columnSeparator: csvSeparator,
+        };
+    }
 }

package/src/Api/Internal/RowFormInternalApi.js

@@ -187,7 +187,7 @@ export class RowFormInternalApi extends ApiBase {
         }
         const returnValues = this.getGridApi().internalApi.getDistinctDisplayValuesForColumnOld(column.columnId);
         // FIXME add support for asynchronous custom select cell editor values
-        // it involves refactoring the AdaptableForm & AdapatableFormComponent
+        // it involves refactoring the AdaptableForm & adaptableFormComponent
         // await this.getSelectCellEditorValuesForColumn(
         //   column,
         //   gridCell

package/src/Api/ThemeApi.d.ts

@@ -81,6 +81,8 @@ export interface ThemeApi {
     openThemeSettingsPanel(): void;
     /**
      * Get the name of the current AG Grid theme
+     *
+     * @deprecated required only for legacy AG Grid themes, see https://www.ag-grid.com/javascript-data-grid/theming-v32/
      */
     getAgGridCurrentThemeName(): string;
 }

package/src/PredefinedConfig/AlertState.d.ts

@@ -150,4 +150,4 @@ export type SystemAlertPredicateIds = SystemAlertPredicateId[];
 /**
  * List of System Predicates available for Alerts
  */
-export type SystemAlertPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'PercentChange' | 'IsNumeric' | 'IsNotNumeric' | 'In' | 'NotIn' | 'AnyChange';
+export type SystemAlertPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'PercentChange' | 'In' | 'NotIn' | 'AnyChange';

package/src/PredefinedConfig/Common/AdaptableColumnContext.d.ts

@@ -5,7 +5,7 @@ import { BaseContext } from './BaseContext';
  */
 export interface AdaptableColumnContext<TData = any> extends BaseContext {
     /**
-     * Column being filtered
+     * The current Column
      */
     column: AdaptableColumn<TData>;
 }

package/src/PredefinedConfig/Common/AdaptablePredicate.d.ts

@@ -104,7 +104,7 @@ export interface PredicateDefHandlerContext extends BaseContext {
      * Any (optional) inputs required to perform evaluation
      */
     inputs?: any[];
-    predicatesLogic?: ColumnFilter['PredicatesLogic'];
+    predicatesOperator?: ColumnFilter['PredicatesOperator'];
 }
 /**
  * Inputs required for a Predicate

package/src/PredefinedConfig/Common/AdaptablePredicate.js

@@ -1,16 +1,16 @@
-import isAfter from 'date-fns/isAfter';
-import isBefore from 'date-fns/isBefore';
-import isEqual from 'date-fns/isEqual';
-import isFuture from 'date-fns/isFuture';
-import isPast from 'date-fns/isPast';
-import isSameDay from 'date-fns/isSameDay';
-import isThisMonth from 'date-fns/isThisMonth';
-import isThisQuarter from 'date-fns/isThisQuarter';
-import isThisWeek from 'date-fns/isThisWeek';
-import isThisYear from 'date-fns/isThisYear';
-import isToday from 'date-fns/isToday';
-import isTomorrow from 'date-fns/isTomorrow';
-import isYesterday from 'date-fns/isYesterday';
+import { isAfter } from 'date-fns';
+import { isBefore } from 'date-fns';
+import { isEqual } from 'date-fns';
+import { isFuture } from 'date-fns';
+import { isPast } from 'date-fns';
+import { isSameDay } from 'date-fns';
+import { isThisMonth } from 'date-fns';
+import { isThisQuarter } from 'date-fns';
+import { isThisWeek } from 'date-fns';
+import { isThisYear } from 'date-fns';
+import { isToday } from 'date-fns';
+import { isTomorrow } from 'date-fns';
+import { isYesterday } from 'date-fns';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { parseDateValue } from '../../Utilities/Helpers/DateHelper';
 import Helper from '../../Utilities/Helpers/Helper';
@@ -266,22 +266,6 @@ export const SystemPredicateDefs = [
         toString: ({ inputs }) => `Not Between ${inputs[0] ?? ''}:${inputs[1]}`,
         shortcuts: ['!:'],
     },
-    {
-        id: 'IsNumeric',
-        label: 'Is Numeric',
-        icon: { text: '1' },
-        columnScope: { DataTypes: ['number'] },
-        moduleScope: ['alert', 'flashingcell'],
-        handler: ({ value }) => !isNaN(Number(value)),
-    },
-    {
-        id: 'IsNotNumeric',
-        label: 'Is Not Numeric',
-        icon: { text: '1' },
-        columnScope: { DataTypes: ['number'] },
-        moduleScope: ['alert', 'flashingcell'],
-        handler: ({ value }) => isNaN(Number(value)),
-    },
     // String System Filters
     {
         id: 'Is',

package/src/PredefinedConfig/Common/ColumnFilter.d.ts

@@ -13,10 +13,10 @@ export interface ColumnFilter extends SuspendableObject {
      */
     Predicates: ColumnFilterPredicate[];
     /**
-     * The Logic to use when combining multiple Predicates
+     * Logic used when combining multiple Predicates ('AND'|'OR')
      * @defaultValue 'AND'
      */
-    PredicatesLogic?: 'AND' | 'OR';
+    PredicatesOperator?: PredicatesOperator;
 }
 /**
  * A Predicate used in Column Filtering
@@ -24,6 +24,10 @@ export interface ColumnFilter extends SuspendableObject {
 export interface ColumnFilterPredicate extends AdaptablePredicate {
     PredicateId: TypeHint<string, SystemFilterPredicateId>;
 }
+/**
+ * Logic used to join multiple Predicates
+ */
+export type PredicatesOperator = 'AND' | 'OR';
 /**
  * Array containing all System Filter Predicates
  */

package/src/PredefinedConfig/ExportState.d.ts

@@ -3,9 +3,9 @@ import { BaseSchedule } from './Common/Schedule';
 import { ColumnScope } from './Common/ColumnScope';
 import { AdaptableColumnBase } from './Common/AdaptableColumn';
 import { AdaptableObject } from './Common/AdaptableObject';
-import { AdaptableFormData } from './Common/AdaptableForm';
 import { AdaptableBooleanQuery } from './Common/AdaptableQuery';
 import { TypeHint } from './Common/Types';
+import { ExportDestinationType } from '../AdaptableOptions/ExportOptions';
 /**
  * Predefined Configuration for Export Module
  */
@@ -61,9 +61,15 @@ export interface ReportSchedule extends BaseSchedule {
      */
     ReportFormat: ReportFormatType;
     /**
-     * Additional data for a Custom Destination produced by a Dynamic Form
+     * Destination of Report to run on Schedule
      */
-    ExportDestinationData?: AdaptableFormData;
+    ExportDestination?: ExportDestinationType;
+}
+export interface ReportColumn extends AdaptableColumnBase {
+    /**
+     * Field in the row to get cell data from; defaults to `columnId`
+     */
+    field?: string;
 }
 /**
  * Defines the data in a Report run by AdapTable
@@ -76,7 +82,7 @@ export interface ReportData {
     /**
      * Columns in the Report
      */
-    columns: AdaptableColumnBase[];
+    columns: ReportColumn[];
     /**
      * Group columns IDs in the Report
      */
@@ -86,19 +92,6 @@ export interface ReportData {
      */
     pivotColumnIds?: string[];
 }
-/**
- * Row Data in the Report
- */
-export interface ReportRow {
-    /**
-     * Data for the row
-     */
-    data: Record<string, any>;
-    /**
-     * Optional children rows for grouped data
-     */
-    children?: ReportRow[];
-}
 /**
  * System report names provided by AdapTable
  */

package/src/PredefinedConfig/FlashingCellState.d.ts

@@ -72,4 +72,4 @@ export type SystemFlashingCellPredicateIds = SystemFlashingCellPredicateId[];
 /**
  * List of System Predicates available for Flashing Cells
  */
-export type SystemFlashingCellPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'PercentChange' | 'IsNumeric' | 'IsNotNumeric' | 'In' | 'NotIn' | 'AnyChange';
+export type SystemFlashingCellPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'PercentChange' | 'In' | 'NotIn' | 'AnyChange';

package/src/PredefinedConfig/LayoutState.d.ts

@@ -51,7 +51,7 @@ export interface LayoutBase extends AdaptableObject {
      */
     ColumnHeaders?: ColumnStringMap;
     /**
-     * Whether to include aggFunc name in the Column header: e.g. 'sum(Price)' will just be 'Price'
+     * Whether to include aggFunc name in Column header: e.g. 'sum(Price)' becomes 'Price'
      */
     SuppressAggFuncInHeader?: boolean;
     /**
@@ -88,7 +88,7 @@ export interface TableLayout extends LayoutBase {
      */
     RowSummaries?: RowSummary[];
     /**
-     * Columns showing aggregated values in Group Rows; 1st value in record is Column name, 2nd is either aggfunc (e.g. sum, avg etc.) or 'true' (to use default aggfunc)
+     * Columns showing aggregated values in Grouped Rows; a record of ColumnId and aggfunc (e.g. sum) or 'true' (to use default aggfunc)
      */
     TableAggregationColumns?: TableAggregationColumns;
     /**
@@ -100,19 +100,19 @@ export interface TableLayout extends LayoutBase {
      */
     RowGroupDisplayType?: 'single' | 'multi';
     /**
-     * Pivot Columns - can NOT be provided
+     * Pivot Columns - must NOT be provided
      */
     PivotColumns?: never;
     /**
-     * Pivot Group Columns - can NOT be provided
+     * Pivot Group Columns - must NOT be provided
      */
     PivotGroupedColumns?: never;
     /**
-     * Pivot Expansions - can NOT be provided
+     * Pivot Expansions - must NOT be provided
      */
     PivotExpandLevel?: never;
     /**
-     * Pivot Aggregation Columns - can NOT be provided
+     * Pivot Aggregation Columns - must NOT be provided
      */
     PivotAggregationColumns?: never;
 }
@@ -125,7 +125,7 @@ export interface PivotLayout extends LayoutBase {
      */
     PivotColumns: string[];
     /**
-     * How deep to expand Pivots
+     * How deep to expand Pivot Columns (0 for none, 1 for 1st level only etc, -1 to expand all)
      */
     PivotExpandLevel?: number;
     /**
@@ -137,31 +137,31 @@ export interface PivotLayout extends LayoutBase {
      */
     PivotGroupedColumns?: string[];
     /**
-     * Table Columns - can NOT be provided
+     * Table Columns - must NOT be provided
      */
     TableColumns?: never;
     /**
-     * Table Aggregation Columns - can NOT be provided
+     * Table Aggregation Columns - must NOT be provided
      */
     TableAggregationColumns?: never;
     /**
-     * Row Grouped Columns Columns - can NOT be provided
+     * Row Grouped Columns Columns - must NOT be provided
      */
     RowGroupedColumns?: never;
 }
-/**
- * Object used for defining which Row Group Values are Expanded or Collapsed
- */
-export type RowGroupValuesWithExceptionKeys = {
-    RowGroupDefaultBehavior: 'expanded' | 'collapsed';
-    ExceptionGroupKeys?: any[][];
-};
 /**
  * Manages how (and which) Row Group values are stored
  */
 export type RowGroupValues = {
     RowGroupDefaultBehavior: 'always-expanded' | 'always-collapsed';
 } | RowGroupValuesWithExceptionKeys;
+/**
+ * Defines which Row Group Values are expanded or collapsed
+ */
+export type RowGroupValuesWithExceptionKeys = {
+    RowGroupDefaultBehavior: 'expanded' | 'collapsed';
+    ExceptionGroupKeys?: any[][];
+};
 /**
  * Defines a map of Columns with a String value
  */

package/src/PredefinedConfig/StyledColumnState.d.ts

@@ -32,7 +32,7 @@ export interface StyledColumn extends SuspendableObject {
     /**
      * Displays a Sparkline Chart in an array column
      */
-    SparkLineStyle?: SparklineStyle;
+    SparklineStyle?: SparklineStyle;
     /**
      * Displays cell values in Column as a Badge
      */

package/src/Redux/ActionsReducers/LayoutRedux.d.ts

@@ -99,7 +99,8 @@ export interface LayoutColumnFilterEditAction extends LayoutColumnFilterAction {
 }
 export interface LayoutColumnFilterSetAction extends LayoutColumnFilterAction {
 }
-export interface LayoutColumnFilterClearAction extends LayoutColumnFilterAction {
+export interface LayoutColumnFilterClearAction extends Redux.Action {
+    columnId: string;
 }
 export interface LayoutColumnFilterClearAllAction extends Redux.Action {
 }
@@ -121,7 +122,7 @@ export declare const LayoutColumnFilterAdd: (columnFilter: ColumnFilter) => Layo
 export declare const LayoutColumnFilterEdit: (columnFilter: ColumnFilter) => LayoutColumnFilterEditAction;
 export declare const LayoutColumnFilterSet: (columnFilter: ColumnFilter) => LayoutColumnFilterSetAction;
 export declare const LayoutColumnFilterClearAll: () => LayoutColumnFilterClearAllAction;
-export declare const LayoutColumnFilterClear: (columnFilter: ColumnFilter) => LayoutColumnFilterClearAction;
+export declare const LayoutColumnFilterClear: (columnId: string) => LayoutColumnFilterClearAction;
 export declare const LayoutColumnFilterSuspend: (columnFilter: ColumnFilter) => LayoutColumnFilterSuspendAction;
 export declare const LayoutColumnFilterUnSuspend: (columnFilter: ColumnFilter) => LayoutColumnFilterUnSuspendAction;
 export declare const LayoutColumnFilterSuspendAll: () => LayoutColumnFilterSuspendAllAction;
@@ -180,7 +181,7 @@ export declare const getCurrentLayoutSelector: (state: AdaptableState) => Layout
 export declare const getColumnFilterSelector: (state: AdaptableState, columnId: string) => {
     ColumnId: string;
     Predicates: import("../../types").ColumnFilterPredicate[];
-    PredicatesLogic?: "AND" | "OR";
+    PredicatesOperator?: import("../../types").PredicatesOperator;
     IsSuspended?: boolean;
     Uuid?: string;
     Source?: "Config" | "User";

package/src/Redux/ActionsReducers/LayoutRedux.js

@@ -105,9 +105,9 @@ export const LayoutColumnFilterSet = (columnFilter) => ({
 export const LayoutColumnFilterClearAll = () => ({
     type: LAYOUT_COLUMN_FILTER_CLEAR_ALL,
 });
-export const LayoutColumnFilterClear = (columnFilter) => ({
+export const LayoutColumnFilterClear = (columnId) => ({
     type: LAYOUT_COLUMN_FILTER_CLEAR,
-    columnFilter,
+    columnId,
 });
 export const LayoutColumnFilterSuspend = (columnFilter) => ({
     type: LAYOUT_COLUMN_FILTER_SUSPEND,
@@ -338,7 +338,7 @@ export const LayoutReducer = (state = initialState, action) => {
             const actionTypedDelete = action;
             const columnFilters = (currentLayout.ColumnFilters ?? []).filter((cf) => {
                 // make sure we are deleting all filters on the same column
-                return cf.ColumnId !== actionTypedDelete.columnFilter.ColumnId;
+                return cf.ColumnId !== actionTypedDelete.columnId;
             });
             const Layouts = state.Layouts.map((layout) => {
                 if (layout.Name === currentLayout.Name) {