@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.1

package/src/Api/Implementation/LayoutApiImpl.js

@@ -6,43 +6,55 @@ import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import ObjectFactory from '../../Utilities/ObjectFactory';
 import Helper from '../../Utilities/Helpers/Helper';
 import { createUuid } from '../../PredefinedConfig/Uuid';
-import { DEFAULT_LAYOUT } from '../../Utilities/Constants/GeneralConstants';
 import { PopupShowPrompt } from '../../Redux/ActionsReducers/PopupRedux';
 import { LayoutInternalApi } from '../Internal/LayoutInternalApi';
+import { isPivotLayout, normalizeLayout } from './LayoutHelpers';
+import { ERROR_LAYOUT } from '../../Utilities/Constants/GeneralConstants';
 export class LayoutApiImpl extends ApiBase {
     constructor(_adaptable) {
         super(_adaptable);
-        this.shouldAutoSaveLayouts = () => {
-            var _a;
-            return (_a = this.getLayoutOptions()) === null || _a === void 0 ? void 0 : _a.autoSaveLayouts;
-        };
         this.internalApi = new LayoutInternalApi(_adaptable);
     }
+    updateCurrentLayout(updateFn) {
+        const currentLayout = this.getCurrentLayout();
+        const updatedLayout = normalizeLayout(updateFn(structuredClone(currentLayout)));
+        this._adaptable.setLayout(updatedLayout);
+    }
     isCurrentLayoutPivot() {
-        return this.getCurrentLayout().EnablePivot;
+        return isPivotLayout(this.getCurrentLayout());
     }
     getLayoutState() {
         return this.getAdaptableState().Layout;
     }
-    getCurrentVisibleColumnIdsMap() {
+    getCurrentVisibleColumnIdsMapForTableLayout() {
         const layout = this.getCurrentLayout();
-        return layout.Columns.reduce((acc, colId) => {
+        if (isPivotLayout(layout)) {
+            return {};
+        }
+        return layout.TableColumns.reduce((acc, colId) => {
             acc[colId] = true;
             return acc;
         }, {});
     }
-    getCurrentVisibleColumnIds() {
-        return this.getCurrentLayout().Columns;
+    getCurrentVisibleColumnIdsForTableLayout() {
+        const layout = this.getCurrentLayout();
+        if (isPivotLayout(layout)) {
+            return [];
+        }
+        return layout.TableColumns.filter((colId) => layout.ColumnVisibility?.[colId] !== false);
     }
     getCurrentRowGroupsColumnIds() {
-        return this.getCurrentLayout().RowGroupedColumns;
+        const layout = this.getCurrentLayout();
+        if (isPivotLayout(layout)) {
+            return layout.PivotGroupedColumns;
+        }
+        return layout.RowGroupedColumns;
     }
     setLayout(layoutName) {
-        var _a;
         if (StringExtensions.IsNullOrEmpty(layoutName)) {
             return;
         }
-        if (((_a = this.getLayoutOptions()) === null || _a === void 0 ? void 0 : _a.autoSaveLayouts) && layoutName === this.getCurrentLayoutName()) {
+        if (layoutName === this.getCurrentLayoutName()) {
             return;
         }
         let layout = this.getLayoutByName(layoutName);
@@ -51,17 +63,12 @@ export class LayoutApiImpl extends ApiBase {
         }
     }
     getCurrentLayout() {
-        const state = this.getAdaptableState();
-        if (state.Grid.CurrentLayout) {
-            return state.Grid.CurrentLayout;
-        }
-        let layoutName = state.Layout.CurrentLayout;
-        return (this.getLayoutByName(layoutName) || ObjectFactory.CreateEmptyLayout({ Name: DEFAULT_LAYOUT }));
+        let layoutName = this.getLayoutState().CurrentLayout;
+        return this.getLayoutByName(layoutName) ?? ERROR_LAYOUT;
     }
     getCurrentLayoutColumnSort(columnId) {
-        var _a, _b, _c, _d;
         const currentLayout = this.getCurrentLayout();
-        return ((_d = (_c = (_b = (_a = currentLayout === null || currentLayout === void 0 ? void 0 : currentLayout.ColumnSorts) === null || _a === void 0 ? void 0 : _a.find) === null || _b === void 0 ? void 0 : _b.call(_a, (sort) => sort.ColumnId === columnId)) === null || _c === void 0 ? void 0 : _c.SortOrder) !== null && _d !== void 0 ? _d : null);
+        return (currentLayout?.ColumnSorts?.find?.((sort) => sort.ColumnId === columnId)?.SortOrder ?? null);
     }
     getCurrentLayoutName() {
         return this.getAdaptableState().Layout.CurrentLayout;
@@ -136,19 +143,13 @@ export class LayoutApiImpl extends ApiBase {
         };
     }
     getLayouts() {
-        var _a;
-        return (_a = this.getAdaptableState().Layout.Layouts) !== null && _a !== void 0 ? _a : [];
+        return this.getAdaptableState().Layout.Layouts ?? [];
     }
     getLayoutById(id) {
-        var _a;
-        return (_a = this.getLayouts()) === null || _a === void 0 ? void 0 : _a.find((layout) => (layout === null || layout === void 0 ? void 0 : layout.Uuid) === id);
+        return this.getLayouts()?.find((layout) => layout?.Uuid === id);
     }
     saveCurrentLayout() {
-        var _a;
         let currentLayout = this.getCurrentLayout();
-        if (!((_a = this.getLayoutOptions()) === null || _a === void 0 ? void 0 : _a.autoSaveLayouts)) {
-            currentLayout = this.getAdaptableState().Grid.CurrentLayout || currentLayout;
-        }
         if (currentLayout) {
             this.createOrUpdateLayout(currentLayout);
         }
@@ -172,7 +173,7 @@ export class LayoutApiImpl extends ApiBase {
             this.logError("Cannot create layout with the Name: '" + layoutToCreate.Name + "' as it already exists");
             return false;
         }
-        const newLayout = ObjectFactory.CreateEmptyLayout(Object.assign({}, layoutToCreate));
+        const newLayout = ObjectFactory.CreateEmptyLayout({ ...layoutToCreate });
         this.addUidToAdaptableObject(newLayout);
         this.dispatchAction(LayoutRedux.LayoutAdd(newLayout));
         return newLayout;
@@ -212,18 +213,19 @@ export class LayoutApiImpl extends ApiBase {
         }
     }
     showChangeColumnCaption(column) {
+        const customHeader = this.getCurrentLayout().ColumnHeaders?.[column.columnId] ?? column.friendlyName;
         this.dispatchAction(PopupShowPrompt({
             Header: `Change caption for '${column.friendlyName}'`,
             Msg: '',
-            DefaultValue: column.friendlyName,
-            ConfirmActionCreator: (inputText) => inputText !== column.friendlyName &&
+            DefaultValue: customHeader,
+            ConfirmActionCreator: (inputText) => inputText !== customHeader &&
                 LayoutSetColumnCaption(this.getCurrentLayoutName(), column.columnId, inputText),
         }));
     }
     openLayoutSettingsPanel() {
         this.showModulePopup(ModuleConstants.LayoutModuleId);
     }
-    showLayoutEditor(layoutName, action = 'Edit') {
+    showLayoutEditor(layoutName, layoutType, action = 'Edit') {
         let preparedAction = action;
         if (!['Edit', 'New', 'Clone'].includes(action)) {
             preparedAction = 'Edit';
@@ -237,6 +239,9 @@ export class LayoutApiImpl extends ApiBase {
             source: 'Toolbar',
             action: preparedAction,
             value: layout,
+            config: {
+                layoutType,
+            },
         });
     }
     isCurrentLayoutReadOnly() {
@@ -247,10 +252,6 @@ export class LayoutApiImpl extends ApiBase {
         return true;
     }
     deleteLayout(layout) {
-        if (layout.Name === DEFAULT_LAYOUT) {
-            this.logWarn('The Default Layout cannot be deleted');
-            return;
-        }
         const layoutCount = this.getLayouts().length;
         if (layoutCount === 1) {
             this.logWarn('You cannot delete the only Layout.  AdapTable always requires one layout');
@@ -266,12 +267,6 @@ export class LayoutApiImpl extends ApiBase {
         }
         return this.deleteLayout(layout);
     }
-    isDefaultLayout(layout) {
-        return layout.Name === DEFAULT_LAYOUT;
-    }
-    isCurrentLayoutDefault() {
-        return this.isDefaultLayout(this.getCurrentLayout());
-    }
     removeColumnFromCurrentLayout(columnId) {
         this.removeColumnFromLayout(columnId, this.getCurrentLayoutName());
     }
@@ -284,27 +279,27 @@ export class LayoutApiImpl extends ApiBase {
         const column = this.getColumnApi().getColumnWithColumnId(columnId);
         if (column) {
             const layout = this.getLayoutByName(layoutName);
-            if (layout) {
-                if (layout.Columns.includes(columnId)) {
+            if (layout && !isPivotLayout(layout)) {
+                if (layout.TableColumns.includes(columnId)) {
                     this.dispatchAction(LayoutRedux.LayoutRemoveColumn(layoutName, columnId));
                     this.getColumnApi().hideColumn(columnId);
                 }
             }
         }
     }
-    addColumnToLayout(columnId, layoutName) {
+    addColumnToTableLayout(columnId, layoutName) {
         const column = this.getColumnApi().getColumnWithColumnId(columnId);
         if (column) {
             const layout = this.getLayoutByName(layoutName);
-            if (layout) {
-                if (!layout.Columns.includes(columnId)) {
+            if (layout && !isPivotLayout(layout)) {
+                if (!layout.TableColumns.includes(columnId)) {
                     this.dispatchAction(LayoutRedux.LayoutAddColumn(layoutName, columnId));
                     this.getColumnApi().showColumn(columnId);
                 }
             }
         }
     }
-    addColumnToCurrentLayout(columnId) {
-        this.addColumnToLayout(columnId, this.getCurrentLayoutName());
+    addColumnToCurrentTableLayout(columnId) {
+        this.addColumnToTableLayout(columnId, this.getCurrentLayoutName());
     }
 }

package/src/Api/Implementation/LayoutHelpers.d.ts

@@ -0,0 +1,23 @@
+import { TableLayout, PivotLayout, Layout } from '../../types';
+import { LayoutModel, TableLayoutModel, PivotLayoutModel } from '../../layout-manager/src/LayoutManagerModel';
+export declare const layoutStateToLayoutModel: (layout: TableLayout | PivotLayout) => LayoutModel;
+export declare const layoutModelToLayoutState: (layoutModel: LayoutModel, defaults: TableLayout | PivotLayout) => TableLayout | PivotLayout;
+/**
+ * Compares 2 Layouts for equality
+ * @param layout1 First Layout
+ * @param layout2 Second Layout
+ */
+export declare const areLayoutsEqual: (layout1: Layout, layout2: Layout) => boolean;
+export declare const normalizeLayout: (layout: TableLayout | PivotLayout, options?: {
+    isTree: boolean;
+}) => TableLayout | PivotLayout;
+export declare const normalizeTableLayout: (tableLayout: TableLayout, options?: {
+    isTree: boolean;
+}) => TableLayout;
+export declare const normalizePivotLayout: (pivotLayout: PivotLayout) => PivotLayout;
+export declare const checkForDuplicateColumns: (layout: TableLayout) => void;
+export declare const tableLayoutToTableLayoutModel: (tableLayout: TableLayout) => TableLayoutModel;
+export declare const pivotLayoutToPivotLayoutModel: (pivotLayout: PivotLayout) => PivotLayoutModel;
+export declare const tableLayoutModelToTableLayout: (layoutModel: TableLayoutModel, defaults: TableLayout) => TableLayout;
+export declare const pivotLayoutModelToPivotLayout: (layoutModel: PivotLayoutModel, defaults: PivotLayout) => PivotLayout;
+export declare const isPivotLayout: (layout: Partial<Layout>) => layout is PivotLayout;

package/src/Api/Implementation/LayoutHelpers.js

@@ -0,0 +1,303 @@
+import isEqual from 'lodash/isEqual';
+import { isPivotLayoutModel } from '../../layout-manager/src/isPivotLayoutModel';
+import { normalizeTableLayoutModel, normalizePivotLayoutModel, } from '../../layout-manager/src/normalizeLayoutModel';
+import { simplifyTableLayoutModel, simplifyPivotLayoutModel, } from '../../layout-manager/src/simplifyLayoutModel';
+import { isWeightedAverageAggregation, WEIGHTED_AVERAGE_AGG_FN_NAME, isWeightedAverageAggFuncName, } from '../../PredefinedConfig/Common/AggregationColumns';
+export const layoutStateToLayoutModel = (layout) => {
+    if (isPivotLayout(layout)) {
+        return pivotLayoutToPivotLayoutModel(layout);
+    }
+    return tableLayoutToTableLayoutModel(layout);
+};
+export const layoutModelToLayoutState = (layoutModel, defaults) => {
+    if (isPivotLayoutModel(layoutModel)) {
+        return pivotLayoutModelToPivotLayout(layoutModel, defaults);
+    }
+    return tableLayoutModelToTableLayout(layoutModel, defaults);
+};
+function cleanupAdaptableObjectPrimitives(layout) {
+    if (layout.TableAggregationColumns) {
+        layout.TableAggregationColumns.forEach((AggValue) => {
+            // @ts-ignore
+            delete AggValue.Source;
+            // @ts-ignore
+            delete AggValue.Uuid;
+            // @ts-ignore
+            delete AggValue.AdaptableVersion;
+            if (typeof AggValue.AggFunc === 'object' && AggValue.AggFunc) {
+                // @ts-ignore
+                delete AggValue.AggFunc.Source;
+                // @ts-ignore
+                delete AggValue.AggFunc.Uuid;
+                // @ts-ignore
+                delete AggValue.AggFunc.AdaptableVersion;
+            }
+        });
+    }
+    if (layout.ColumnHeaders) {
+        delete layout.ColumnHeaders.Source;
+        delete layout.ColumnHeaders.Uuid;
+        delete layout.ColumnHeaders.AdaptableVersion;
+    }
+    if (layout.ColumnVisibility) {
+        delete layout.ColumnVisibility.Source;
+        delete layout.ColumnVisibility.Uuid;
+        delete layout.ColumnVisibility.AdaptableVersion;
+    }
+    if (layout.ColumnWidths) {
+        delete layout.ColumnWidths.Source;
+        delete layout.ColumnWidths.Uuid;
+        delete layout.ColumnWidths.AdaptableVersion;
+    }
+    if (layout.RowGroupValues) {
+        // @ts-ignore
+        delete layout.RowGroupValues.Source;
+        // @ts-ignore
+        delete layout.RowGroupValues.Uuid;
+        // @ts-ignore
+        delete layout.RowGroupValues.AdaptableVersion;
+    }
+}
+/**
+ * Compares 2 Layouts for equality
+ * @param layout1 First Layout
+ * @param layout2 Second Layout
+ */
+export const areLayoutsEqual = (layout1, layout2) => {
+    if (!layout1 && !layout2) {
+        return true;
+    }
+    if (!layout1 || !layout2) {
+        return false;
+    }
+    return isEqual(normalizeLayout(layout1), normalizeLayout(layout2));
+};
+export const normalizeLayout = (layout, options) => {
+    if (isPivotLayout(layout)) {
+        return normalizePivotLayout(layout);
+    }
+    return normalizeTableLayout(layout, options);
+};
+export const normalizeTableLayout = (tableLayout, options) => {
+    const Source = tableLayout.Source;
+    const Uuid = tableLayout.Uuid;
+    const AdaptableVersion = tableLayout.AdaptableVersion;
+    let model = tableLayoutToTableLayoutModel(tableLayout);
+    model = normalizeTableLayoutModel(model, options);
+    tableLayout = tableLayoutModelToTableLayout(model, tableLayout);
+    if (Source) {
+        tableLayout.Source = Source;
+    }
+    if (Uuid) {
+        tableLayout.Uuid = Uuid;
+    }
+    if (AdaptableVersion) {
+        tableLayout.AdaptableVersion = AdaptableVersion;
+    }
+    return tableLayout;
+};
+export const normalizePivotLayout = (pivotLayout) => {
+    const Source = pivotLayout.Source;
+    const Uuid = pivotLayout.Uuid;
+    const AdaptableVersion = pivotLayout.AdaptableVersion;
+    let model = pivotLayoutToPivotLayoutModel(pivotLayout);
+    model = normalizePivotLayoutModel(model);
+    pivotLayout = pivotLayoutModelToPivotLayout(model, pivotLayout);
+    if (Source) {
+        pivotLayout.Source = Source;
+    }
+    if (Uuid) {
+        pivotLayout.Uuid = Uuid;
+    }
+    if (AdaptableVersion) {
+        pivotLayout.AdaptableVersion = AdaptableVersion;
+    }
+    return pivotLayout;
+};
+const errorOnceMessages = new Map();
+const errorOnce = (message) => {
+    if (errorOnceMessages.get(message)) {
+        return;
+    }
+    console.error(message);
+    errorOnceMessages.set(message, true);
+};
+export const checkForDuplicateColumns = (layout) => {
+    if (layout.TableColumns) {
+        const set = new Set(layout.TableColumns);
+        if (set.size !== layout.TableColumns.length) {
+            layout.TableColumns.reduce((acc, col) => {
+                acc[col] = (acc[col] || 0) + 1;
+                if (acc[col] > 1) {
+                    // if you change this message, make sure you also update the associated test error-on-duplicate-column.spec.ts
+                    errorOnce(`Duplicate column "${col}" in layout "${layout.Name}"!`);
+                }
+                return acc;
+            }, {});
+        }
+    }
+};
+export const tableLayoutToTableLayoutModel = (tableLayout) => {
+    tableLayout = structuredClone(tableLayout);
+    cleanupAdaptableObjectPrimitives(tableLayout);
+    if (tableLayout.RowGroupValues) {
+        // @ts-ignore
+        delete tableLayout.RowGroupValues.Source;
+        // @ts-ignore
+        delete tableLayout.RowGroupValues.Uuid;
+        // @ts-ignore
+        delete tableLayout.RowGroupValues.AdaptableVersion;
+    }
+    delete tableLayout.ColumnHeaders;
+    const TableAggregationColumns = (tableLayout.TableAggregationColumns || []).map(({ ColumnId, AggFunc }) => {
+        return {
+            ColumnId,
+            AggFunc: toAggFunc(AggFunc),
+        };
+    });
+    const result = simplifyTableLayoutModel({
+        SuppressAggFuncInHeader: tableLayout.SuppressAggFuncInHeader,
+        TableColumns: tableLayout.TableColumns,
+        ColumnWidths: tableLayout.ColumnWidths,
+        ColumnVisibility: tableLayout.ColumnVisibility,
+        ColumnSorts: tableLayout.ColumnSorts,
+        // ColumnHeaders: tableLayout.ColumnHeaders,
+        RowGroupedColumns: tableLayout.RowGroupedColumns,
+        ColumnPinning: tableLayout.ColumnPinning,
+        RowGroupValues: tableLayout.RowGroupValues
+            ? tableLayout.RowGroupValues.RowGroupDefaultBehavior === 'always-collapsed' ||
+                tableLayout.RowGroupValues.RowGroupDefaultBehavior === 'always-expanded'
+                ? {
+                    RowGroupDisplay: tableLayout.RowGroupValues.RowGroupDefaultBehavior,
+                }
+                : {
+                    RowGroupDisplay: tableLayout.RowGroupValues.RowGroupDefaultBehavior,
+                    Values: tableLayout.RowGroupValues.ExceptionGroupKeys || [],
+                }
+            : undefined,
+        TableAggregationColumns: TableAggregationColumns,
+    });
+    if (tableLayout.RowGroupDisplayType) {
+        result.RowGroupDisplayType = tableLayout.RowGroupDisplayType;
+    }
+    return result;
+};
+export const pivotLayoutToPivotLayoutModel = (pivotLayout) => {
+    pivotLayout = structuredClone(pivotLayout);
+    cleanupAdaptableObjectPrimitives(pivotLayout);
+    delete pivotLayout.ColumnHeaders;
+    const result = simplifyPivotLayoutModel({
+        SuppressAggFuncInHeader: pivotLayout.SuppressAggFuncInHeader,
+        ColumnWidths: pivotLayout.ColumnWidths,
+        ColumnVisibility: pivotLayout.ColumnVisibility,
+        ColumnSorts: pivotLayout.ColumnSorts,
+        PivotGroupedColumns: pivotLayout.PivotGroupedColumns,
+        ColumnPinning: pivotLayout.ColumnPinning,
+        PivotColumns: pivotLayout.PivotColumns,
+        PivotExpandLevel: pivotLayout.PivotExpandLevel,
+        PivotAggregationColumns: (pivotLayout.PivotAggregationColumns || []).map(({ ColumnId, AggFunc }) => {
+            return {
+                ColumnId,
+                AggFunc: toAggFunc(AggFunc),
+            };
+        }),
+    });
+    return result;
+};
+function toAggFunc(aggFunc) {
+    if (isWeightedAverageAggregation(aggFunc)) {
+        return { aggFunc: WEIGHTED_AVERAGE_AGG_FN_NAME, weightedColumnId: aggFunc.weightedColumnId };
+    }
+    return { aggFunc };
+}
+export const tableLayoutModelToTableLayout = (layoutModel, defaults) => {
+    const tableLayout = {
+        ...defaults,
+        TableColumns: layoutModel.TableColumns,
+        ColumnWidths: layoutModel.ColumnWidths,
+        ColumnVisibility: layoutModel.ColumnVisibility,
+        ColumnSorts: layoutModel.ColumnSorts,
+    };
+    if (layoutModel.RowGroupDisplayType) {
+        tableLayout.RowGroupDisplayType = layoutModel.RowGroupDisplayType;
+    }
+    if (layoutModel.RowGroupedColumns) {
+        tableLayout.RowGroupedColumns = layoutModel.RowGroupedColumns;
+    }
+    else {
+        delete tableLayout.RowGroupedColumns;
+    }
+    if (layoutModel.ColumnPinning) {
+        tableLayout.ColumnPinning = layoutModel.ColumnPinning;
+    }
+    else {
+        delete tableLayout.ColumnPinning;
+    }
+    if (layoutModel.RowGroupValues) {
+        tableLayout.RowGroupValues = {
+            RowGroupDefaultBehavior: layoutModel.RowGroupValues.RowGroupDisplay,
+        };
+        if ((layoutModel.RowGroupValues.RowGroupDisplay === 'collapsed' ||
+            layoutModel.RowGroupValues.RowGroupDisplay === 'expanded') &&
+            layoutModel.RowGroupValues.Values) {
+            // @ts-ignore
+            tableLayout.RowGroupValues.ExceptionGroupKeys = layoutModel.RowGroupValues.Values;
+        }
+    }
+    else {
+        delete tableLayout.RowGroupValues;
+    }
+    if (layoutModel.TableAggregationColumns) {
+        tableLayout.TableAggregationColumns = layoutModel.TableAggregationColumns.map(({ ColumnId, AggFunc }) => {
+            return {
+                ColumnId,
+                AggFunc: toAggregationColumnValue(AggFunc),
+            };
+        });
+    }
+    else {
+        delete tableLayout.TableAggregationColumns;
+    }
+    return tableLayout;
+};
+function toAggregationColumnValue(columnAggregationModel) {
+    return columnAggregationModel &&
+        typeof columnAggregationModel.aggFunc === 'string' &&
+        isWeightedAverageAggFuncName(columnAggregationModel.aggFunc)
+        ? {
+            type: 'weightedAverage',
+            weightedColumnId: columnAggregationModel.weightedColumnId,
+        }
+        : columnAggregationModel.aggFunc;
+}
+export const pivotLayoutModelToPivotLayout = (layoutModel, defaults) => {
+    const pivotLayout = {
+        ...defaults,
+        PivotColumns: layoutModel.PivotColumns,
+        TableColumns: layoutModel.TableColumns,
+        ColumnWidths: layoutModel.ColumnWidths,
+        ColumnVisibility: layoutModel.ColumnVisibility,
+        ColumnSorts: layoutModel.ColumnSorts,
+        ColumnPinning: layoutModel.ColumnPinning,
+    };
+    if (layoutModel.PivotGroupedColumns) {
+        pivotLayout.PivotGroupedColumns = layoutModel.PivotGroupedColumns;
+    }
+    else {
+        delete pivotLayout.PivotGroupedColumns;
+    }
+    if (!layoutModel.RowGroupValues) {
+        delete pivotLayout.RowGroupValues;
+    }
+    if (layoutModel.PivotAggregationColumns) {
+        pivotLayout.PivotAggregationColumns = (layoutModel.PivotAggregationColumns || []).map(({ ColumnId, AggFunc }) => ({
+            ColumnId,
+            AggFunc: toAggregationColumnValue(AggFunc),
+        }));
+    }
+    else {
+        delete pivotLayout.PivotAggregationColumns;
+    }
+    return pivotLayout;
+};
+export const isPivotLayout = (layout) => Array.isArray(layout.PivotColumns);

package/src/Api/Implementation/NamedQueryApiImpl.js

@@ -24,7 +24,7 @@ export class NamedQueryApiImpl extends ApiBase {
         return this.getNamedQueries().find((se) => se.Name == namedQueryName);
     }
     isValidNamedQuery(namedQuery) {
-        if (IsNullOrEmptyOrWhiteSpace(namedQuery === null || namedQuery === void 0 ? void 0 : namedQuery.Name)) {
+        if (IsNullOrEmptyOrWhiteSpace(namedQuery?.Name)) {
             return { valid: false, message: 'Named Query name cannot be blank' };
         }
         // check that there is no other existing named query with the same name

package/src/Api/Implementation/NoteApiImpl.js

@@ -20,7 +20,10 @@ export class NoteApiImpl extends ApiBase {
         this.dispatchAction(NoteRedux.NoteEdit(note));
     }
     updateNoteText(noteStr, note) {
-        this.editNote(Object.assign(Object.assign({}, note), { Text: noteStr }));
+        this.editNote({
+            ...note,
+            Text: noteStr,
+        });
     }
     deleteNote(note) {
         this.dispatchAction(NoteRedux.NoteDelete(note));

package/src/Api/Implementation/OptionsApiImpl.d.ts

@@ -1,25 +1,21 @@
 import { ApiBase } from './ApiBase';
-import { ActionColumnOptions, ActionRowOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, ColumnOptions, NoteOptions, ContainerOptions, DashboardOptions, DataChangeHistoryOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, NotificationsOptions, OptionsApi, QuickSearchOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions, GridFilterOptions, ColumnMenuOptions, ContextMenuOptions } from '../../types';
-import { GroupingOptions } from '../../AdaptableOptions/GroupingOptions';
-import { CustomSortOptions } from '../../AdaptableOptions/CustomSortOptions';
-import { Fdc3Options } from '../../AdaptableOptions/Fdc3Options';
-import { ExpressionOptions } from '../../AdaptableOptions/ExpressionOptions';
-import { ColumnFilterOptions } from '../../AdaptableOptions/ColumnFilterOptions';
-import { CommentOptions } from '../../AdaptableOptions/CommentOptions';
+import { ActionColumnOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, ColumnOptions, NoteOptions, ContainerOptions, DashboardOptions, DataChangeHistoryOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, NotificationsOptions, OptionsApi, QuickSearchOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions, ColumnMenuOptions, ContextMenuOptions, FilterOptions, CustomSortOptions, Fdc3Options, ExpressionOptions, CommentOptions, PredicateOptions, RowFormOptions } from '../../types';
 export declare class OptionsApiImpl extends ApiBase implements OptionsApi {
     getAdaptableId(): string;
     getAdaptableStateKey(): string;
-    getAutogeneratePrimaryKey(): boolean;
+    isAutogeneratePrimaryKey(): boolean;
     getLicenseKey(): string;
     getPrimaryKey(): string;
     getUserName(): string;
+    getAdaptableContext<TContext = Record<string, any>>(): TContext;
     getAdaptableOptions(): AdaptableOptions;
     getActionColumnOptions(): ActionColumnOptions;
-    getActionRowOptions(): ActionRowOptions;
+    getRowFormOptions(): RowFormOptions;
     getCellSummaryOptions(): CellSummaryOptions;
     getCalendarOptions(): CalendarOptions;
     getColumnOptions(): ColumnOptions;
     getNoteOptions(): NoteOptions;
+    getPredicateOptions(): PredicateOptions;
     getCommentOptions(): Readonly<CommentOptions<any>>;
     getCustomSortOptions(): CustomSortOptions;
     getContainerOptions(): ContainerOptions;
@@ -29,12 +25,10 @@ export declare class OptionsApiImpl extends ApiBase implements OptionsApi {
     getDashboardOptions(): DashboardOptions;
     getEditOptions(): EditOptions;
     getExportOptions(): ExportOptions;
-    getGroupingOptions(): GroupingOptions;
     getLayoutOptions(): LayoutOptions;
     getColumnMenuOptions(): ColumnMenuOptions;
     getContextMenuOptions(): ContextMenuOptions;
-    getColumnFilterOptions(): ColumnFilterOptions;
-    getGridFilterOptions(): Readonly<GridFilterOptions<any>>;
+    getFilterOptions(): FilterOptions;
     getExpressionOptions(): ExpressionOptions;
     getQuickSearchOptions(): QuickSearchOptions;
     getFormatColumnOptions(): FormatColumnOptions;
@@ -49,4 +43,7 @@ export declare class OptionsApiImpl extends ApiBase implements OptionsApi {
     getSettingsPanelOptions(): SettingsPanelOptions;
     getFdc3Options(): Fdc3Options;
     getDataImportOptions(): import("../../types").DataImportOptions<Record<string, any>>;
+    addToAdaptableContext<TContext = Record<string, any>>(key: keyof TContext, value: TContext[keyof TContext]): void;
+    removeFromAdaptableContext<TContext = Record<string, any>>(key: keyof TContext): void;
+    clearAdaptableContext(): void;
 }