@adaptabletools/adaptable-cjs 18.0.0-canary.3 → 18.0.0-canary.31

package/src/agGrid/AgGridOptionsService.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgGridOptionsService = void 0;
+class AgGridOptionsService {
+    constructor(adaptableInstance) {
+        this.adaptableInstance = adaptableInstance;
+        this.gridOptionsPropertyCache = new Map();
+        this.colDefPropertyCache = new Map();
+    }
+    destroy() {
+        this.gridOptionsPropertyCache.clear();
+        this.colDefPropertyCache.clear();
+        this.gridOptionsPropertyCache = null;
+        this.colDefPropertyCache = null;
+    }
+    setGridOptionsProperty(gridOptions, propertyName, propertyGetter) {
+        if (this.adaptableInstance.lifecycleState === 'preDestroyed') {
+            return;
+        }
+        const userKey = `user.${propertyName}`;
+        const adaptableKey = `adaptable.${propertyName}`;
+        const value = gridOptions[propertyName];
+        const isUserDefined = value !== this.gridOptionsPropertyCache.get(adaptableKey);
+        if (isUserDefined) {
+            this.gridOptionsPropertyCache.set(userKey, value);
+        }
+        const userValue = this.gridOptionsPropertyCache.get(userKey);
+        let adaptableValue = propertyGetter(userValue);
+        if (typeof adaptableValue === 'function') {
+            const previousValue = adaptableValue;
+            // @ts-ignore we know that adaptableValue is a function
+            adaptableValue = (...args) => {
+                if (this.adaptableInstance.isDestroyed) {
+                    return;
+                }
+                this.agGridAdapter.grabAgGridApiOnTheFly(args);
+                return previousValue(...args);
+            };
+        }
+        if (adaptableValue != null) {
+            this.gridOptionsPropertyCache.set(adaptableKey, adaptableValue);
+        }
+        gridOptions[propertyName] = adaptableValue !== null && adaptableValue !== void 0 ? adaptableValue : userValue;
+        return gridOptions;
+    }
+    getUserGridOptionsProperty(propertyName) {
+        const userKey = `user.${propertyName}`;
+        return this.gridOptionsPropertyCache.get(userKey);
+    }
+    revertGridOptionsPropertyToUserValue(propertyName) {
+        const userKey = `user.${propertyName}`;
+        const userValue = this.gridOptionsPropertyCache.get(userKey);
+        this.agGridAdapter.setGridOption(propertyName, userValue);
+    }
+    CAREFUL_patchGridOptionsProperty(propertyName, value) {
+        var _a;
+        // @ts-ignore this is required to set gridOptions peroperties which are marked as initial (writable once, before grid is initialised)
+        const gos = (_a = this.agGridAdapter.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.gos;
+        if (gos) {
+            gos.updateGridOptions({
+                options: {
+                    [propertyName]: value,
+                },
+                source: 'api',
+            });
+        }
+    }
+    revertGridOptionsPropertiesToUserValue(gridOptions, propertyNames) {
+        for (const propertyName of propertyNames) {
+            // see this.setGridOptionsProperty(...)
+            const userKey = `user.${propertyName}`;
+            const userValue = this.gridOptionsPropertyCache.get(userKey);
+            gridOptions[propertyName] = userValue;
+        }
+    }
+    get agGridAdapter() {
+        return this.adaptableInstance.agGridAdapter;
+    }
+}
+exports.AgGridOptionsService = AgGridOptionsService;

package/src/agGrid/BadgeRenderer.d.ts

@@ -1,4 +1,4 @@
-import { StyledColumn } from '../PredefinedConfig/StyledColumnState';
+import { BadgeStyle } from '../PredefinedConfig/StyledColumnState';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-export declare const getBadgeRendererForColumn: (styledColumn: StyledColumn, abColumn: AdaptableColumn, api: AdaptableApi) => any;
+export declare const getBadgeRendererForColumn: (badgeStyle: BadgeStyle, abColumn: AdaptableColumn, api: AdaptableApi) => any;

package/src/agGrid/BadgeRenderer.js

@@ -5,25 +5,39 @@ const tslib_1 = require("tslib");
 const Badge_1 = require("../View/Components/Badge");
 const renderWithAdaptableContext_1 = require("../View/renderWithAdaptableContext");
 const React = tslib_1.__importStar(require("react"));
-const getBadgeRendererForColumn = (styledColumn, abColumn, api) => {
-    if (!styledColumn.BadgeStyle) {
-        return;
-    }
+const RowSummary_1 = require("../PredefinedConfig/Common/RowSummary");
+const getBadgeRendererForColumn = (badgeStyle, abColumn, api) => {
     return class BadgetRenderer {
         getAdaptableInstance(params) {
-            const adaptable = params.api.__adaptable;
+            const adaptable = params.context.__adaptable;
             return adaptable;
         }
         init(params) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e, _f, _g;
             const adaptable = this.getAdaptableInstance(params);
             const adapatableApi = adaptable.api;
             this.eGui = document.createElement('div');
             this.eGui.className = 'ab-Badge__wrapper';
-            const includeGrouped = Boolean(styledColumn.IncludeGroupedRows);
-            const isGrouped = params.node.group;
-            if (includeGrouped === false && isGrouped) {
-                const formattedValue = (_c = (_b = (_a = params.formatValue) === null || _a === void 0 ? void 0 : _a.call(params, params.value)) !== null && _b !== void 0 ? _b : params.value) !== null && _c !== void 0 ? _c : '';
+            const isGroupedRow = params.node.group;
+            const isSummaryRow = (_a = params === null || params === void 0 ? void 0 : params.data) === null || _a === void 0 ? void 0 : _a[RowSummary_1.ROW_SUMMARY_ROW_ID];
+            let shouldRender = true;
+            if (isGroupedRow) {
+                if ((_b = badgeStyle.RowScope) === null || _b === void 0 ? void 0 : _b.ExcludeGroupedRows) {
+                    shouldRender = false;
+                }
+            }
+            else if (isSummaryRow) {
+                if ((_c = badgeStyle.RowScope) === null || _c === void 0 ? void 0 : _c.ExcludeSummaryRows) {
+                    shouldRender = false;
+                }
+            }
+            else {
+                if ((_d = badgeStyle.RowScope) === null || _d === void 0 ? void 0 : _d.ExcludeDataRows) {
+                    shouldRender = false;
+                }
+            }
+            if (!shouldRender) {
+                const formattedValue = (_g = (_f = (_e = params.formatValue) === null || _e === void 0 ? void 0 : _e.call(params, params.value)) !== null && _f !== void 0 ? _f : params.value) !== null && _g !== void 0 ? _g : '';
                 this.eGui.innerHTML = formattedValue;
                 return;
             }
@@ -54,7 +68,7 @@ const getBadgeRendererForColumn = (styledColumn, abColumn, api) => {
                     userName: adapatableApi.optionsApi.getUserName(),
                     adaptableId: adapatableApi.optionsApi.getAdaptableId(),
                 };
-                const badge = api.styledColumnApi.internalApi.getApplicableBadge(styledColumn, predicateDefHandlerContext);
+                const badge = api.styledColumnApi.internalApi.getApplicableBadge(badgeStyle, predicateDefHandlerContext);
                 const isNullValue = formattedValue === '' || formattedValue === null || formattedValue === undefined;
                 if (!isNullValue && badge) {
                     badgesConfig.push({
@@ -78,7 +92,7 @@ const getBadgeRendererForColumn = (styledColumn, abColumn, api) => {
                 userName: adapatableApi.optionsApi.getUserName(),
                 adaptableId: adapatableApi.optionsApi.getAdaptableId(),
             };
-            const badge = api.styledColumnApi.internalApi.getApplicableBadge(styledColumn, predicateDefHandlerContext);
+            const badge = api.styledColumnApi.internalApi.getApplicableBadge(badgeStyle, predicateDefHandlerContext);
             const isNullValue = formattedValue === '' || formattedValue === null || formattedValue === undefined;
             if (
             // empty values

package/src/agGrid/CheckboxRenderer.js

@@ -69,7 +69,7 @@ class CheckboxEditor {
     // however, using ReactUI makes some race conditions possible, in which cases the editor will be displayed for a few milliseconds
     // we provide this logic for those few cases (to avoid a flicker effect)
     init(params) {
-        const adaptable = params.api.__adaptable;
+        const adaptable = params.context.__adaptable;
         const inputElement = document.createElement('input');
         inputElement.type = 'checkbox';
         inputElement.checked = params.value;

package/src/agGrid/FilterWrapper.d.ts

@@ -1,2 +1,2 @@
-import { Adaptable } from './Adaptable';
-export declare let FilterWrapperFactory: (adaptable: Adaptable) => any;
+import { AdaptableAgGrid } from './AdaptableAgGrid';
+export declare const FilterWrapperFactory: (adaptable: AdaptableAgGrid) => any;

package/src/agGrid/FilterWrapper.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const react_1 = require("react");
 const FilterForm_1 = require("../View/Components/FilterForm/FilterForm");
-let FilterWrapperFactory = (adaptable) => {
+const FilterWrapperFactory = (adaptable) => {
     function isFilterActive(colId) {
         // we need this here
         if (adaptable.isDestroyed) {

package/src/agGrid/PercentBarRenderer.js

@@ -17,7 +17,8 @@ const getPercentBarRendererForColumn = (styledColumn, abColumn, api) => {
             if (Helper_1.default.objectNotExists(value)) {
                 value = 0;
             }
-            if (!styledColumn.IncludeGroupedRows && api.gridApi.isGroupRowNode(params.node)) {
+            // No longer support showing Percent Bar in Grouped Rows
+            if (api.gridApi.isGroupRowNode(params.node)) {
                 if (params.value) {
                     this.eGui = document.createElement('div');
                     this.eGui.append(params.value);

package/src/agGrid/attachAddaptableColumnTypes.d.ts

@@ -1,16 +1,16 @@
 import { GridOptions } from '@ag-grid-community/core';
 export declare const attachColumnTypes: (gridOptions: GridOptions) => {
-    [key: string]: import("@ag-grid-community/core").ColDef<any, any>;
+    [key: string]: import("@ag-grid-community/core").ColTypeDef<any, any>;
 } & {
-    [x: string]: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefNumber: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefString: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefBoolean: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefDate: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefObject: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefCustom: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefStringArray: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefNumberArray: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefTupleNumberArray: import("@ag-grid-community/core").ColDef<any, any>;
-    abColDefObjectNumberArray: import("@ag-grid-community/core").ColDef<any, any>;
+    [x: string]: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefNumber: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefString: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefBoolean: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefDate: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefObject: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefCustom: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefStringArray: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefNumberArray: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefTupleNumberArray: import("@ag-grid-community/core").ColTypeDef<any, any>;
+    abColDefObjectNumberArray: import("@ag-grid-community/core").ColTypeDef<any, any>;
 };

package/src/agGrid/buildSortedColumnStateForLayout.d.ts

@@ -0,0 +1,7 @@
+import { ColumnState, GridOptions } from '@ag-grid-community/core';
+import { Layout } from '../types';
+export declare function buildSortedColumnStateForLayout(params: {
+    columnState: ColumnState[];
+    layout: Layout;
+    gridOptions: GridOptions;
+}): ColumnState[];

package/src/agGrid/buildSortedColumnStateForLayout.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSortedColumnStateForLayout = void 0;
+const GeneralConstants_1 = require("../Utilities/Constants/GeneralConstants");
+const ColumnInternalApi_1 = require("../Api/Internal/ColumnInternalApi");
+const ColumnApiImpl_1 = require("../Api/Implementation/ColumnApiImpl");
+const sortColumnStateForVisibleColumns_1 = require("./sortColumnStateForVisibleColumns");
+function buildSortedColumnStateForLayout(params) {
+    const { columnState, layout, gridOptions } = params;
+    let visibleColumnList = [...layout.Columns];
+    const multipleGroupColumns = gridOptions.groupDisplayType === 'multipleColumns';
+    const singleGroupColumn = !multipleGroupColumns;
+    const rowGroupedColumnsIndexes = {};
+    let generatedRowGroupColumnsIds = [];
+    // here we make sure the visibleColumnList includes all the generated group columns
+    if (layout.RowGroupedColumns) {
+        layout.RowGroupedColumns.forEach((colId, index) => {
+            rowGroupedColumnsIndexes[colId] = index;
+            rowGroupedColumnsIndexes[(0, ColumnInternalApi_1.getAutoRowGroupColumnIdFor)(colId)] = index;
+        });
+        // if the layout does not include the grouped columns,
+        // make sure we add the grouped columns to the visible column list
+        // at the start of the list
+        if (singleGroupColumn) {
+            if (!visibleColumnList.includes(GeneralConstants_1.AG_GRID_GROUPED_COLUMN)) {
+                visibleColumnList = [GeneralConstants_1.AG_GRID_GROUPED_COLUMN, ...visibleColumnList];
+            }
+            generatedRowGroupColumnsIds.push(GeneralConstants_1.AG_GRID_GROUPED_COLUMN);
+        }
+        else {
+            let missingGroupColumns = 0;
+            [...layout.RowGroupedColumns].reverse().forEach((colId) => {
+                const groupColId = (0, ColumnInternalApi_1.getAutoRowGroupColumnIdFor)(colId);
+                if (!visibleColumnList.includes(groupColId)) {
+                    visibleColumnList = [groupColId, ...visibleColumnList];
+                    missingGroupColumns++;
+                }
+                generatedRowGroupColumnsIds = [groupColId, ...generatedRowGroupColumnsIds];
+            });
+            // now we need to sort the visibleColumnList to contain the group columns
+            // in the correct order
+            // but we only need to do this if the layout.Columns list missed some of the
+            // group columns, but not all of them. if all were missing, we already
+            // inserted them at the start of the list
+            if (missingGroupColumns && missingGroupColumns < layout.RowGroupedColumns.length) {
+                visibleColumnList.sort((colId1, colId2) => {
+                    const isRowGroup1 = (0, ColumnApiImpl_1.isAutoRowGroupColumn)(colId1);
+                    const isRowGroup2 = (0, ColumnApiImpl_1.isAutoRowGroupColumn)(colId2);
+                    if (isRowGroup1 && isRowGroup2) {
+                        return rowGroupedColumnsIndexes[colId1] - rowGroupedColumnsIndexes[colId2];
+                    }
+                    return 0;
+                });
+            }
+        }
+    }
+    const visibleColumnsIndexes = visibleColumnList.reduce((acc, colId, index) => {
+        acc[colId] = index;
+        return acc;
+    }, {});
+    const pivotMode = layout.EnablePivot;
+    if (pivotMode) {
+        // in pivot mode, we sort the Visible columns of the layout
+        // to make sure the group cols are at the beginning
+        const groupCols = visibleColumnList.filter(ColumnApiImpl_1.isAutoRowGroupColumn);
+        visibleColumnList = visibleColumnList.filter((colId) => !(0, ColumnApiImpl_1.isAutoRowGroupColumn)(colId));
+        visibleColumnList = [...groupCols, ...visibleColumnList];
+    }
+    // we're now ready to go over the columnState
+    // we want as much as possible to keep the order of the columns
+    // as they are in the column state.
+    // if the order is different in the visibleColumns, we only move those columns around
+    // if some columns in the columnState are not in the visibleColumns, we need to return them as hide: true
+    // first step - keep the same order, but filter out old group columns
+    // VERY IMPORTANT to only filter out OLD group columns, that is,
+    // group columns that are not in the layout anymore
+    // since we might have different group columns in the layout
+    let newColumnState = [...columnState].filter((colState) => {
+        const { colId } = colState;
+        if ((0, ColumnApiImpl_1.isAutoRowGroupColumn)(colId) && rowGroupedColumnsIndexes[colId] == null) {
+            return false;
+        }
+        return true;
+    });
+    // second step - keep the same order
+    // but make sure the visibility is adjusted to reflect the
+    // visible columns in the layout
+    newColumnState = newColumnState.map((colState) => {
+        const { colId } = colState;
+        const visibleIndex = visibleColumnsIndexes[colId];
+        if (visibleIndex == null) {
+            return Object.assign(Object.assign({}, colState), { hide: true });
+        }
+        return Object.assign(Object.assign({}, colState), { hide: null });
+    });
+    // third step - correctly mark the columns that are grouped
+    newColumnState = newColumnState.map((colState) => {
+        const { colId } = colState;
+        const groupIndex = rowGroupedColumnsIndexes[colId];
+        if (groupIndex != null) {
+            return Object.assign(Object.assign({}, colState), { rowGroup: true, rowGroupIndex: groupIndex });
+        }
+        return Object.assign(Object.assign({}, colState), { rowGroup: false, rowGroupIndex: null });
+    });
+    // fourth step - add the new group columns, if they are missing
+    const columnStateIndexes = newColumnState.reduce((acc, colState, index) => {
+        acc[colState.colId] = index;
+        return acc;
+    }, {});
+    generatedRowGroupColumnsIds.reverse().forEach((rowGroupColId) => {
+        if (columnStateIndexes[rowGroupColId] == null) {
+            newColumnState = [
+                {
+                    colId: rowGroupColId,
+                },
+                ...newColumnState,
+            ];
+        }
+    });
+    // fitfth step - sort the column state to respect the order of the visible columns
+    // we can't simply call sort in this case
+    return (0, sortColumnStateForVisibleColumns_1.sortColumnStateForVisibleColumns)(newColumnState, visibleColumnList);
+}
+exports.buildSortedColumnStateForLayout = buildSortedColumnStateForLayout;

package/src/agGrid/defaultAdaptableOptions.d.ts

@@ -0,0 +1,3 @@
+import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
+export declare function applyDefaultAdaptableOptions(adaptableOptions: AdaptableOptions): AdaptableOptions;
+export declare const getDefaultAdaptableOptions: () => AdaptableOptions<any>;

package/src/{Utilities/Defaults/DefaultAdaptableOptions.js → agGrid/defaultAdaptableOptions.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultAdaptableOptions = void 0;
+exports.getDefaultAdaptableOptions = exports.applyDefaultAdaptableOptions = void 0;
 const tslib_1 = require("tslib");
-const GeneralConstants = tslib_1.__importStar(require("../Constants/GeneralConstants"));
-const GeneralConstants_1 = require("../Constants/GeneralConstants");
-const UIHelper_1 = tslib_1.__importStar(require("../../View/UIHelper"));
-const AdaptablePredicate_1 = require("../../PredefinedConfig/Common/AdaptablePredicate");
-const Enums_1 = require("../../PredefinedConfig/Common/Enums");
-const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
-// change type to DeepRequired<AdaptableOptions> to check which properties have no default values defined
-exports.DefaultAdaptableOptions = {
+const GeneralConstants = tslib_1.__importStar(require("../Utilities/Constants/GeneralConstants"));
+const UIHelper_1 = tslib_1.__importStar(require("../View/UIHelper"));
+const GeneralConstants_1 = require("../Utilities/Constants/GeneralConstants");
+const Enums_1 = require("../PredefinedConfig/Common/Enums");
+const AdaptablePredicate_1 = require("../PredefinedConfig/Common/AdaptablePredicate");
+const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
+const AdaptableHelper_1 = require("../Utilities/Helpers/AdaptableHelper");
+const DefaultAdaptableOptions = {
     adaptableId: GeneralConstants.ADAPTABLE_ID,
     adaptableStateKey: undefined,
     primaryKey: '',
@@ -147,8 +147,6 @@ exports.DefaultAdaptableOptions = {
     customSortOptions: { customSortComparers: undefined },
     dataSetOptions: { dataSets: GeneralConstants_1.EMPTY_ARRAY },
     groupingOptions: {
-        showGroupingTotalsAsHeader: false,
-        balancedGroupsKey: undefined,
         restoreUngroupedColumns: false,
         autoOrderGroupedColumns: true,
     },
@@ -173,13 +171,6 @@ exports.DefaultAdaptableOptions = {
     menuOptions: {
         customColumnMenu: undefined,
         customContextMenu: undefined,
-        showAdaptableContextMenu: true,
-        showAdaptableColumnMenu: true,
-        showUngroupColumnMenuItem: true,
-        columnMenuOrder: ['aggrid', 'adaptable', 'user'],
-        contextMenuOrder: ['aggrid', 'adaptable', 'user'],
-        columnMenuItems: undefined,
-        contextMenuItems: undefined,
     },
     columnFilterOptions: {
         quickFilterOptions: {
@@ -201,7 +192,7 @@ exports.DefaultAdaptableOptions = {
             sortValuesFilter: false,
             filterValuesUsingTime: false,
             showDistinctFilteredValuesOnly: false,
-            maxFilterValuesToDisplay: 2000,
+            maxFilterValuesToDisplay: undefined,
             includeBlankFilterValues: false,
             showValuesCount: undefined,
         },
@@ -223,6 +214,7 @@ exports.DefaultAdaptableOptions = {
         enableFilterOnSpecialColumns: true,
         showClearFilterButton: false,
         showSuspendFilterButton: false,
+        showDatePicker: true,
     },
     gridFilterOptions: {
         availableFilterEditors: ['ExpressionEditor', 'QueryBuilder'],
@@ -254,6 +246,7 @@ exports.DefaultAdaptableOptions = {
         loadState: undefined,
         persistState: undefined,
         clearState: undefined,
+        autoMigrateState: true,
     },
     teamSharingOptions: {
         enableTeamSharing: false,
@@ -272,6 +265,9 @@ exports.DefaultAdaptableOptions = {
         useCustomMacLikeScrollbars: false,
         englishVariant: 'GB',
         showLoadingScreen: true,
+        loadingScreenDelay: 200,
+        loadingScreenTitle: 'Initialising Grid',
+        loadingScreenText: 'Retrieving your settings and setting up the grid...',
         disableDeleteConfirmation: false,
         dateInputOptions: {
             useNativeInput: false,
@@ -329,3 +325,62 @@ exports.DefaultAdaptableOptions = {
         },
     },
 };
+function applyDefaultAdaptableOptions(adaptableOptions) {
+    var _a;
+    const adaptableOptsWithDefaults = Object.assign({}, DefaultAdaptableOptions, adaptableOptions);
+    adaptableOptsWithDefaults.adaptableStateKey =
+        (_a = adaptableOptsWithDefaults.adaptableStateKey) !== null && _a !== void 0 ? _a : adaptableOptsWithDefaults.adaptableId;
+    adaptableOptsWithDefaults.dataImportOptions = Object.assign({}, DefaultAdaptableOptions.dataImportOptions, adaptableOptions.dataImportOptions);
+    adaptableOptsWithDefaults.expressionOptions = Object.assign({}, DefaultAdaptableOptions.expressionOptions, adaptableOptions.expressionOptions);
+    adaptableOptsWithDefaults.calendarOptions = Object.assign({}, DefaultAdaptableOptions.calendarOptions, adaptableOptions.calendarOptions);
+    adaptableOptsWithDefaults.columnOptions = Object.assign({}, DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
+    adaptableOptsWithDefaults.customSortOptions = Object.assign({}, DefaultAdaptableOptions.customSortOptions, adaptableOptions.customSortOptions);
+    adaptableOptsWithDefaults.dataSetOptions = Object.assign({}, DefaultAdaptableOptions.dataSetOptions, adaptableOptions.dataSetOptions);
+    adaptableOptsWithDefaults.cellSummaryOptions = Object.assign({}, DefaultAdaptableOptions.cellSummaryOptions, adaptableOptions.cellSummaryOptions);
+    adaptableOptsWithDefaults.predicateOptions = Object.assign({}, DefaultAdaptableOptions.predicateOptions, adaptableOptsWithDefaults.predicateOptions);
+    adaptableOptsWithDefaults.layoutOptions = Object.assign({}, DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
+    adaptableOptsWithDefaults.notificationsOptions = Object.assign({}, DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
+    adaptableOptsWithDefaults.alertOptions = Object.assign({}, DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
+    adaptableOptsWithDefaults.flashingCellOptions = Object.assign({}, DefaultAdaptableOptions.flashingCellOptions, adaptableOptions.flashingCellOptions);
+    adaptableOptsWithDefaults.entitlementOptions = Object.assign({}, DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
+    adaptableOptsWithDefaults.dashboardOptions = Object.assign({}, DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
+    adaptableOptsWithDefaults.editOptions = Object.assign({}, DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
+    adaptableOptsWithDefaults.actionColumnOptions = Object.assign({}, DefaultAdaptableOptions.actionColumnOptions, adaptableOptions.actionColumnOptions);
+    // to do
+    adaptableOptsWithDefaults.actionRowOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions, adaptableOptions.actionRowOptions);
+    adaptableOptsWithDefaults.actionRowOptions.actionRowButtonOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions.actionRowButtonOptions, adaptableOptsWithDefaults.actionRowOptions.actionRowButtonOptions);
+    adaptableOptsWithDefaults.actionRowOptions.actionRowFormOptions = Object.assign({}, DefaultAdaptableOptions.actionRowOptions.actionRowFormOptions, adaptableOptsWithDefaults.actionRowOptions.actionRowFormOptions);
+    adaptableOptsWithDefaults.containerOptions = Object.assign({}, DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
+    adaptableOptsWithDefaults.groupingOptions = Object.assign({}, DefaultAdaptableOptions.groupingOptions, adaptableOptions.groupingOptions);
+    adaptableOptsWithDefaults.quickSearchOptions = Object.assign({}, DefaultAdaptableOptions.quickSearchOptions, adaptableOptions.quickSearchOptions);
+    adaptableOptsWithDefaults.columnFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions, adaptableOptions.columnFilterOptions);
+    adaptableOptsWithDefaults.columnFilterOptions.quickFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.quickFilterOptions, adaptableOptsWithDefaults.columnFilterOptions.quickFilterOptions);
+    adaptableOptsWithDefaults.columnFilterOptions.filterFormOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.filterFormOptions, adaptableOptsWithDefaults.columnFilterOptions.filterFormOptions);
+    adaptableOptsWithDefaults.columnFilterOptions.valuesFilterOptions = Object.assign({}, DefaultAdaptableOptions.columnFilterOptions.valuesFilterOptions, adaptableOptsWithDefaults.columnFilterOptions.valuesFilterOptions);
+    adaptableOptsWithDefaults.gridFilterOptions = Object.assign({}, DefaultAdaptableOptions.gridFilterOptions, adaptableOptions.gridFilterOptions);
+    adaptableOptsWithDefaults.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
+    adaptableOptsWithDefaults.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, adaptableOptsWithDefaults.userInterfaceOptions.dateInputOptions);
+    adaptableOptsWithDefaults.menuOptions = Object.assign({}, DefaultAdaptableOptions.menuOptions, adaptableOptions.menuOptions);
+    adaptableOptsWithDefaults.stateOptions = Object.assign({}, DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
+    adaptableOptsWithDefaults.exportOptions = Object.assign({}, DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
+    adaptableOptsWithDefaults.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
+    adaptableOptsWithDefaults.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
+    adaptableOptsWithDefaults.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
+    adaptableOptsWithDefaults.chartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions, adaptableOptions.chartingOptions);
+    adaptableOptsWithDefaults.chartingOptions.externalChartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions.externalChartingOptions, adaptableOptsWithDefaults.chartingOptions.externalChartingOptions);
+    adaptableOptsWithDefaults.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
+    adaptableOptsWithDefaults.fdc3Options = Object.assign({}, DefaultAdaptableOptions.fdc3Options, adaptableOptions.fdc3Options);
+    adaptableOptsWithDefaults.fdc3Options.actionColumnDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration, adaptableOptsWithDefaults.fdc3Options.actionColumnDefaultConfiguration);
+    adaptableOptsWithDefaults.fdc3Options.uiControlsDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration, adaptableOptsWithDefaults.fdc3Options.uiControlsDefaultConfiguration);
+    const { predefinedConfig } = adaptableOptsWithDefaults;
+    if (predefinedConfig) {
+        adaptableOptsWithDefaults.predefinedConfig =
+            typeof predefinedConfig === 'string'
+                ? predefinedConfig
+                : (0, AdaptableHelper_1.initPredefinedConfigWithUuids)(predefinedConfig);
+    }
+    return adaptableOptsWithDefaults;
+}
+exports.applyDefaultAdaptableOptions = applyDefaultAdaptableOptions;
+const getDefaultAdaptableOptions = () => DefaultAdaptableOptions;
+exports.getDefaultAdaptableOptions = getDefaultAdaptableOptions;

package/src/agGrid/editors/AdaptableDateEditor/index.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { ICellEditorParams, ICellEditorComp } from '@ag-grid-community/core';
+import { ICellEditorComp, ICellEditorParams } from '@ag-grid-community/core';
 import { IAdaptable } from '../../../AdaptableInterfaces/IAdaptable';
 export declare const ReactAdaptableDateEditor: React.ForwardRefExoticComponent<ICellEditorParams<any, any, any> & {
     showClearButton?: boolean;

package/src/agGrid/editors/AdaptableDateEditor/index.js

@@ -6,8 +6,8 @@ const React = tslib_1.__importStar(require("react"));
 const renderWithAdaptableContext_1 = require("../../../View/renderWithAdaptableContext");
 const InternalAdaptableDateEditor_1 = require("./InternalAdaptableDateEditor");
 const core_1 = require("ag-grid-community");
-const FormatHelper_1 = require("../../../Utilities/Helpers/FormatHelper");
 const react_1 = require("react");
+const FormatHelper_1 = require("../../../Utilities/Helpers/FormatHelper");
 function shouldClearExistingValue(params) {
     return params.eventKey === core_1.KeyCode.BACKSPACE || params.eventKey === core_1.KeyCode.DELETE;
 }
@@ -33,7 +33,7 @@ exports.ReactAdaptableDateEditor = (0, react_1.forwardRef)((props, ref) => {
     const valueRef = (0, react_1.useRef)(initialValue);
     const colValueParser = props.column.getColDef().valueParser;
     const valueParser = typeof colValueParser === 'function' ? colValueParser : defaultDateValueParser;
-    const adaptable = props.api.__adaptable;
+    const adaptable = props.context.__adaptable;
     const editorRef = (0, react_1.useRef)(null);
     (0, react_1.useImperativeHandle)(ref, () => {
         return {
@@ -139,7 +139,7 @@ class AdaptableDateEditor {
     }
     focusOut() { }
     getAdaptableInstance(params) {
-        const adaptable = params.api.__adaptable;
+        const adaptable = params.context.__adaptable;
         return adaptable;
     }
     // after this component has been created and inserted into the grid

package/src/agGrid/editors/AdaptableNumberEditor/index.d.ts

@@ -6,12 +6,12 @@ import { ICellEditorComp, ICellEditorParams } from '@ag-grid-community/core';
 interface AdaptableNumberCellEditorParams extends ICellEditorParams {
     /**
      * Whether to show the clear button. If `true`, it works together with `cellEditorParams.emptyValue`
-     * @default true
+     * @defaultValue true
      */
     showClearButton: boolean;
     /**
      * Value to set for the cell, when the clear button is pressed
-     * @default '' (empty string)
+     * @defaultValue '' (empty string)
      */
     emptyValue: string;
 }

package/src/agGrid/editors/AdaptableNumberEditor/index.js

@@ -39,7 +39,7 @@ exports.ReactAdaptableNumberEditor = (0, react_1.forwardRef)((props, ref) => {
     const [initialValue] = (0, react_1.useState)(() => getStartValue(props));
     const valueRef = (0, react_1.useRef)(initialValue);
     const columnId = props.column.getColId();
-    const adaptable = props.api.__adaptable;
+    const adaptable = props.context.__adaptable;
     const colValueParser = props.column.getColDef().valueParser;
     const valueParser = typeof colValueParser === 'function' ? colValueParser : defaultValueParser;
     function onValueChange(value) {
@@ -138,7 +138,7 @@ class AdaptableNumberEditor {
     // after this component has been created and inserted into the grid
     afterGuiAttached() {
         var _a, _b;
-        const adaptable = this.params.api.__adaptable;
+        const adaptable = this.params.context.__adaptable;
         const defaultValue = this.value;
         const editorElement = (React.createElement(InternalAdaptableNumberEditor_1.InternalAdaptableNumberEditor, { defaultValue: defaultValue, showClearButton: (_a = this.params.showClearButton) !== null && _a !== void 0 ? _a : true, emptyValue: (_b = this.params.emptyValue) !== null && _b !== void 0 ? _b : '', onValueChange: this.onValueChange, ref: (editor) => {
                 this.editor = editor;

package/src/agGrid/sortColumnStateForVisibleColumns.d.ts

@@ -0,0 +1,12 @@
+type ColState = {
+    colId: string;
+    hide?: boolean | null;
+};
+/**
+ * This method takes a column state and the list of visible columns
+ * and returns a new column state that respects the order of the visible columns
+ * while trying to keep the hidden columns in their original order.
+ *
+ */
+export declare function sortColumnStateForVisibleColumns<T extends ColState>(columnState: T[], visibleColumns: string[]): T[];
+export {};