@adaptabletools/adaptable-cjs 18.0.0-canary.4 → 18.0.0-canary.6

package/src/Api/Internal/FreeTextColumnInternalApi.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FreeTextColumnInternalApi = void 0;
+const tslib_1 = require("tslib");
 const ApiBase_1 = require("../Implementation/ApiBase");
+const ObjectFactory_1 = require("../../Utilities/ObjectFactory");
+const AdaptableNumberEditor_1 = require("../../agGrid/editors/AdaptableNumberEditor");
+const AdaptableDateEditor_1 = require("../../agGrid/editors/AdaptableDateEditor");
+const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
 class FreeTextColumnInternalApi extends ApiBase_1.ApiBase {
     /**
      * Checks if a User Edit was in a Free Text Column
@@ -40,5 +46,59 @@ class FreeTextColumnInternalApi extends ApiBase_1.ApiBase {
         });
         return references;
     }
+    getColDefsForFreeTextColumns() {
+        const defaultFreeTextColumnSettings = (0, ObjectFactory_1.CreateEmptyFreeTextColumn)().FreeTextColumnSettings;
+        return this.getFreeTextColumnApi()
+            .getFreeTextColumns()
+            .map((freeTextColumn) => {
+            var _a;
+            const freeTextColumnSettings = Object.assign(Object.assign({}, defaultFreeTextColumnSettings), freeTextColumn.FreeTextColumnSettings);
+            const dataTypeEditor = freeTextColumnSettings.DataType === 'Number'
+                ? AdaptableNumberEditor_1.AdaptableNumberEditor
+                : freeTextColumnSettings.DataType === 'Date'
+                    ? AdaptableDateEditor_1.AdaptableDateEditor
+                    : null;
+            const columnTypes = [
+                GeneralConstants_1.AB_SPECIAL_COLUMN,
+                this.getGridApi().internalApi.getAgGridDataType(freeTextColumnSettings.DataType),
+            ];
+            if (ArrayExtensions_1.default.IsNotNullOrEmpty((_a = freeTextColumn === null || freeTextColumn === void 0 ? void 0 : freeTextColumn.FreeTextColumnSettings) === null || _a === void 0 ? void 0 : _a.ColumnTypes)) {
+                columnTypes.push(...freeTextColumn.FreeTextColumnSettings.ColumnTypes);
+            }
+            const newColDef = {
+                headerName: freeTextColumn.FriendlyName || freeTextColumn.ColumnId,
+                colId: freeTextColumn.ColumnId,
+                editable: true,
+                hide: true,
+                width: freeTextColumnSettings.Width,
+                enableValue: freeTextColumnSettings.Aggregatable,
+                filter: freeTextColumnSettings.Filterable,
+                floatingFilter: freeTextColumnSettings.Filterable,
+                resizable: freeTextColumnSettings.Resizable,
+                enableRowGroup: freeTextColumnSettings.Groupable,
+                sortable: freeTextColumnSettings.Sortable,
+                enablePivot: freeTextColumnSettings.Pivotable,
+                suppressMenu: freeTextColumnSettings.SuppressMenu,
+                suppressMovable: freeTextColumnSettings.SuppressMovable,
+                cellEditor: dataTypeEditor !== null && dataTypeEditor !== void 0 ? dataTypeEditor : (freeTextColumn.TextEditor && freeTextColumn.TextEditor == 'Large'
+                    ? 'agLargeTextCellEditor'
+                    : 'agTextCellEditor'),
+                type: columnTypes,
+                valueSetter: (params) => {
+                    return (params.data[freeTextColumn.ColumnId] = params.newValue);
+                },
+                // use a Boolean Cell Data Type if the Free Text Column is boolean
+                cellDataType: freeTextColumnSettings.DataType && freeTextColumnSettings.DataType == 'Boolean'
+                    ? 'boolean'
+                    : undefined,
+                valueGetter: (params) => this.getFreeTextColumnApi().getFreeTextColumnValueForRowNode(freeTextColumn, params.node),
+            };
+            if (freeTextColumnSettings.HeaderToolTip) {
+                newColDef.headerTooltip = freeTextColumnSettings.HeaderToolTip;
+            }
+            this.getAdaptableApi().logInfo('Setting up FreeText Column: ' + freeTextColumn.ColumnId);
+            return newColDef;
+        });
+    }
 }
 exports.FreeTextColumnInternalApi = FreeTextColumnInternalApi;

package/src/Api/Internal/GridFilterInternalApi.js

@@ -4,7 +4,7 @@ exports.GridFilterInternalApi = void 0;
 const ApiBase_1 = require("../Implementation/ApiBase");
 class GridFilterInternalApi extends ApiBase_1.ApiBase {
     fireGridFilterAppliedEvent() {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const currentGridFilter = this.getGridFilterApi().getCurrentGridFilter();
             const adaptableApi = this.getAdaptableApi();
             const gridFilterAppliedInfo = {

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

@@ -1,12 +1,15 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
-import { IRowNode } from '@ag-grid-community/core';
+import { IRowNode, RowClassParams } from '@ag-grid-community/core';
+import { GridDataChangeTrigger } from '../Events/GridDataChanged';
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
-import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableColumn, AdaptableColumnDataType } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
 import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
 import { EditLookUpPermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
+import { DistinctValuesParams } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableColumnType } from '../../PredefinedConfig/Common/Types';
 export declare class GridInternalApi extends ApiBase {
     /**
      * Fires Grid Sorted Event
@@ -19,7 +22,7 @@ export declare class GridInternalApi extends ApiBase {
     /**
      * Fires Grid Data Changed Event - when a row has changed in AG Grid
      */
-    fireGridDataChangedEvent(dataRows: any[], rowNodes: IRowNode[], rowTrigger: 'Add' | 'Edit' | 'Delete'): void;
+    fireGridDataChangedEvent(dataRows: any[], rowNodes: IRowNode[], rowTrigger: GridDataChangeTrigger): void;
     /**
      * Gets all distinct display values in the Column with the given ColumnId
      * @param columnId Column to check
@@ -39,17 +42,23 @@ export declare class GridInternalApi extends ApiBase {
         }[];
         suppressClientSideFilter: boolean;
     }>;
+    getDistinctFilterListValuesForColumn(column: AdaptableColumn, filter: string, distinctValuesParams: DistinctValuesParams): Promise<{
+        suppressClientSideFilter?: boolean;
+        gridCells: GridCell[];
+    }>;
     /**
      * Gets all distinct Custom Sort values for the Column with the given ColumnId
      * @param columnId Column to check
      */
     getDistinctCustomSortDisplayValuesForColumn(columnId: string): Promise<any[]>;
+    getDistinctCustomSortValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
     /**
      * Gets all distinct Bulk Update values for the Column with the given ColumnId
      * @param columnId Column to check
      * @param selectedGridCells Selected grid cells
      */
     getDistinctBulkUpdateDisplayValuesForColumn(columnId: string, selectedGridCells: GridCell[]): Promise<any[]>;
+    getDistinctBulkUpdateValuesForColumn(column: AdaptableColumn, selectedGridCells: GridCell[], distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
     /**
      * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
      * @param columnId Column to check
@@ -78,4 +87,13 @@ export declare class GridInternalApi extends ApiBase {
     setSelectedRows(selectedRowInfo: SelectedRowInfo): void;
     buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
     getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
+    getAgGridDataType(dataType: AdaptableColumnDataType): AdaptableColumnType;
+    getRowHighlightStyle(params: RowClassParams): {
+        [cssProperty: string]: string;
+    };
+    getAlertRowStyle(params: RowClassParams): {
+        [cssProperty: string]: string;
+    };
+    getAlertRowClass(params: RowClassParams): string | null;
+    getRowHighlightClass(params: RowClassParams): string | null;
 }

package/src/Api/Internal/GridInternalApi.js

@@ -7,12 +7,15 @@ const Enums_1 = require("../../PredefinedConfig/Common/Enums");
 const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
 const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
 const NumberExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/NumberExtensions"));
+const StyleHelper_1 = require("../../Utilities/Helpers/StyleHelper");
+const UIHelper_1 = tslib_1.__importDefault(require("../../View/UIHelper"));
+const ObjectFactory_1 = require("../../Utilities/ObjectFactory");
 class GridInternalApi extends ApiBase_1.ApiBase {
     /**
      * Fires Grid Sorted Event
      */
     fireGridSortedEvent() {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const adaptableSortState = this.adaptable.api.configApi.getAdaptableSortState();
             const adaptableApi = this.getAdaptableApi();
             const gridSortedInfo = {
@@ -28,7 +31,7 @@ class GridInternalApi extends ApiBase_1.ApiBase {
      * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
      */
     fireCellChangedEvent(cellDataChangedInfo) {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const cellChangedInfo = {
                 adaptableApi: this.adaptable.api,
                 cellChange: cellDataChangedInfo,
@@ -42,7 +45,7 @@ class GridInternalApi extends ApiBase_1.ApiBase {
      * Fires Grid Data Changed Event - when a row has changed in AG Grid
      */
     fireGridDataChangedEvent(dataRows, rowNodes, rowTrigger) {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const gridDataChangedInfo = {
                 changedAt: Date.now(),
                 adaptableApi: this.adaptable.api,
@@ -92,7 +95,7 @@ class GridInternalApi extends ApiBase_1.ApiBase {
         const distinctValuesParams = {
             visibleRowsOnly: showFilteredRowsOnly,
         };
-        const { gridCells, suppressClientSideFilter } = await this.adaptable.getDistinctFilterListValuesForColumn(abColumn, filter, distinctValuesParams);
+        const { gridCells, suppressClientSideFilter } = await this.getDistinctFilterListValuesForColumn(abColumn, filter, distinctValuesParams);
         const sortedDistinctValues = this.sortDistinctValues(gridCells, abColumn);
         let shouldShowValuesCount = false;
         const showValuesCountFunction = this.getColumnFilterOptions().valuesFilterOptions.showValuesCount;
@@ -132,6 +135,26 @@ class GridInternalApi extends ApiBase_1.ApiBase {
             suppressClientSideFilter,
         };
     }
+    async getDistinctFilterListValuesForColumn(column, filter, distinctValuesParams) {
+        var _a;
+        const filterPermittedValues = (_a = this.getUserInterfaceApi().getFilterPermittedValuesForColumn(column)) !== null && _a !== void 0 ? _a : {
+            suppressFilterSearchBar: false,
+            values: () => undefined,
+        };
+        let preparedPermittedValues = undefined;
+        try {
+            const filterPermittedValuesParams = Object.assign(Object.assign({}, (0, ObjectFactory_1.createBaseContext)(this.adaptable.api)), { column: column, searchFilter: filter });
+            preparedPermittedValues = await (filterPermittedValues === null || filterPermittedValues === void 0 ? void 0 : filterPermittedValues.values(filterPermittedValuesParams));
+        }
+        catch (error) {
+            this.adaptable.logger.consoleError(`Failed to load filter permitted values`, column, filter, error);
+        }
+        distinctValuesParams.permittedValues = preparedPermittedValues;
+        return {
+            suppressClientSideFilter: filterPermittedValues.suppressFilterSearchBar,
+            gridCells: this.adaptable.getDistinctValuesForColumn(column, distinctValuesParams),
+        };
+    }
     /**
      * Gets all distinct Custom Sort values for the Column with the given ColumnId
      * @param columnId Column to check
@@ -144,11 +167,24 @@ class GridInternalApi extends ApiBase_1.ApiBase {
         const distinctValuesParams = {
             visibleRowsOnly: false,
         };
-        const gridCells = await this.adaptable.getDistinctCustomSortValuesForColumn(abColumn, distinctValuesParams);
+        const gridCells = await this.getDistinctCustomSortValuesForColumn(abColumn, distinctValuesParams);
         return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
             return cv.normalisedValue;
         });
     }
+    async getDistinctCustomSortValuesForColumn(column, distinctValuesParams) {
+        const customSortPermittedValues = await this.getUserInterfaceApi().getCustomSortPermittedValuesForColumn(column);
+        let preparedPermittedValues = undefined;
+        try {
+            const permittedValuesParams = Object.assign(Object.assign({}, (0, ObjectFactory_1.createBaseContext)(this.adaptable.api)), { column: column });
+            preparedPermittedValues = await (customSortPermittedValues === null || customSortPermittedValues === void 0 ? void 0 : customSortPermittedValues.values(permittedValuesParams));
+        }
+        catch (error) {
+            this.adaptable.logger.consoleError(`Failed to load custom sort permitted values`, column, error);
+        }
+        distinctValuesParams.permittedValues = preparedPermittedValues;
+        return this.adaptable.getDistinctValuesForColumn(column, distinctValuesParams);
+    }
     /**
      * Gets all distinct Bulk Update values for the Column with the given ColumnId
      * @param columnId Column to check
@@ -162,11 +198,24 @@ class GridInternalApi extends ApiBase_1.ApiBase {
         const distinctValuesParams = {
             visibleRowsOnly: false,
         };
-        const gridCells = await this.adaptable.getDistinctBulkUpdateValuesForColumn(abColumn, selectedGridCells, distinctValuesParams);
+        const gridCells = await this.getDistinctBulkUpdateValuesForColumn(abColumn, selectedGridCells, distinctValuesParams);
         return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
             return cv.normalisedValue;
         });
     }
+    async getDistinctBulkUpdateValuesForColumn(column, selectedGridCells, distinctValuesParams) {
+        const bulkUpdatePermittedValues = await this.getUserInterfaceApi().getBulkUpdatePermittedValuesForColumn(column);
+        let preparedPermittedValues = undefined;
+        try {
+            const bulkUpdatePermittedValuesParams = Object.assign(Object.assign({}, (0, ObjectFactory_1.createBaseContext)(this.adaptable.api)), { column: column, gridCells: selectedGridCells });
+            preparedPermittedValues = await (bulkUpdatePermittedValues === null || bulkUpdatePermittedValues === void 0 ? void 0 : bulkUpdatePermittedValues.values(bulkUpdatePermittedValuesParams));
+        }
+        catch (error) {
+            this.adaptable.logger.consoleError(`Failed to load bulk permitted values`, error, column, selectedGridCells);
+        }
+        distinctValuesParams.permittedValues = preparedPermittedValues;
+        return this.adaptable.getDistinctValuesForColumn(column, distinctValuesParams);
+    }
     /**
      * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
      * @param columnId Column to check
@@ -261,7 +310,7 @@ class GridInternalApi extends ApiBase_1.ApiBase {
         this.dispatchAction(GridRedux.GridSetSelectedRows(selectedRowInfo));
     }
     buildStandaloneColumnHeader(column) {
-        return this.adaptable.buildStandaloneColumnHeader(column);
+        return this.adaptable.agGridMenuAdapter.buildStandaloneColumnHeader(column);
     }
     getEditLookUpValuesForColumn(editLookUpItem, column, gridCell) {
         if (!editLookUpItem || !column) {
@@ -289,5 +338,75 @@ class GridInternalApi extends ApiBase_1.ApiBase {
         // this will use the columnApi method that first looks for permitted values and then distinct values
         return this.getDistinctDisplayValuesForColumn(column.columnId);
     }
+    getAgGridDataType(dataType) {
+        if (!dataType) {
+            return 'abColDefString';
+        }
+        switch (dataType) {
+            case 'Boolean':
+                return 'abColDefBoolean';
+            case 'Date':
+                return 'abColDefDate';
+            case 'Number':
+                return 'abColDefNumber';
+            case 'Object':
+                return 'abColDefObject';
+            case 'String':
+                return 'abColDefString';
+            case 'NumberArray':
+                return 'abColDefNumberArray';
+            case 'TupleNumberArray':
+                return 'abColDefTupleNumberArray';
+            case 'ObjectNumberArray':
+                return 'abColDefObjectNumberArray';
+            default:
+                return 'abColDefCustom';
+        }
+    }
+    getRowHighlightStyle(params) {
+        var _a;
+        const primaryKeyValue = this.adaptable.getPrimaryKeyValueFromRowNode(params.node, params.api);
+        const highlightRow = (_a = this.getAdaptableApi()
+            .internalApi.getSystemState()
+            .HighlightedRows) === null || _a === void 0 ? void 0 : _a.find((highlightRow) => {
+            return highlightRow.primaryKeyValue === primaryKeyValue;
+        });
+        if (highlightRow) {
+            return (0, StyleHelper_1.convertAdaptableStyleToCSS)(highlightRow.highlightStyle);
+        }
+    }
+    getAlertRowStyle(params) {
+        var _a, _b;
+        const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
+        const highlightRow = (_b = (_a = alert === null || alert === void 0 ? void 0 : alert.alertDefinition) === null || _a === void 0 ? void 0 : _a.AlertProperties) === null || _b === void 0 ? void 0 : _b.HighlightRow;
+        if (highlightRow) {
+            return typeof highlightRow === 'object'
+                ? (0, StyleHelper_1.convertAdaptableStyleToCSS)(highlightRow)
+                : {
+                    backgroundColor: UIHelper_1.default.getColorByMessageType(alert.alertDefinition.MessageType),
+                };
+        }
+        return null;
+    }
+    getAlertRowClass(params) {
+        var _a, _b;
+        const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
+        const highlightRow = (_b = (_a = alert === null || alert === void 0 ? void 0 : alert.alertDefinition) === null || _a === void 0 ? void 0 : _a.AlertProperties) === null || _b === void 0 ? void 0 : _b.HighlightRow;
+        return typeof highlightRow === 'object' && (highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.ClassName)
+            ? highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.ClassName
+            : null;
+    }
+    getRowHighlightClass(params) {
+        var _a;
+        const primaryKeyValue = this.adaptable.getPrimaryKeyValueFromRowNode(params.node, params.api);
+        const highlightRow = (_a = this.getAdaptableApi()
+            .internalApi.getSystemState()
+            .HighlightedRows) === null || _a === void 0 ? void 0 : _a.find((highlightRow) => {
+            return highlightRow.primaryKeyValue === primaryKeyValue;
+        });
+        return typeof (highlightRow === null || highlightRow === void 0 ? void 0 : highlightRow.highlightStyle) === 'object'
+            ? highlightRow.highlightStyle.ClassName
+            : null;
+    }
 }
 exports.GridInternalApi = GridInternalApi;

package/src/Api/Internal/TeamSharingInternalApi.js

@@ -8,7 +8,7 @@ class TeamSharingInternalApi extends ApiBase_1.ApiBase {
      * @param sharedEntity Entity that has been changed
      */
     fireTeamSharingEntityChangedEvent(sharedEntity) {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const teamSharingEntityChangedInfo = {
                 adaptableApi: this.adaptable.api,
                 sharedEntity: sharedEntity,

package/src/EnvVars.d.ts

@@ -0,0 +1,3 @@
+export declare const ADAPTABLE_VERSION: any;
+export declare const ADAPTABLE_PUBLISH_TIMESTAMP: any;
+export declare const INFINITE_TABLE_LICENSE_KEY: any;

package/src/EnvVars.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INFINITE_TABLE_LICENSE_KEY = exports.ADAPTABLE_PUBLISH_TIMESTAMP = exports.ADAPTABLE_VERSION = void 0;
+const tslib_1 = require("tslib");
+const env_1 = tslib_1.__importDefault(require("./env"));
+exports.ADAPTABLE_VERSION = env_1.default.VERSION;
+exports.ADAPTABLE_PUBLISH_TIMESTAMP = env_1.default.PUBLISH_TIMESTAMP;
+exports.INFINITE_TABLE_LICENSE_KEY = env_1.default.INFINITE_TABLE_LICENSE_KEY;

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

@@ -16,3 +16,4 @@ export interface WeightedAverageAggregation {
  * Defines which Columns in a Layout display Aggregated values when Row-Grouped
  */
 export type AggregationColumns = Record<string, string | true | WeightedAverageAggregation>;
+export declare const isWeightedAverageAggregation: (aggFunc: AggregationColumns[keyof AggregationColumns]) => aggFunc is WeightedAverageAggregation;

package/src/PredefinedConfig/Common/AggregationColumns.js

@@ -1,4 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEIGHTED_AVERAGE_AGG_FN_NAME = void 0;
+exports.isWeightedAverageAggregation = exports.WEIGHTED_AVERAGE_AGG_FN_NAME = void 0;
 exports.WEIGHTED_AVERAGE_AGG_FN_NAME = 'weightedAvg';
+const isWeightedAverageAggregation = (aggFunc) => {
+    return (aggFunc === null || aggFunc === void 0 ? void 0 : aggFunc.type) === 'weightedAverage';
+};
+exports.isWeightedAverageAggregation = isWeightedAverageAggregation;

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

@@ -6,6 +6,14 @@ export interface DataUpdateConfig {
      * Whether data should be updated asynchronously
      */
     runAsync?: boolean;
+    /**
+     * Whether to flush async updates.
+     *
+     * If `true`, any async transactions will be flushed.
+     * This flag can be true even if you runAsync is `false`.
+     * So even if the currenct transaction/operation is synchronous, this will flush existing async transactions.
+     */
+    flushAsync?: boolean;
     /**
      * Callback function invoked when a batch successfully updates
      */

package/src/Redux/Store/AdaptableStore.d.ts

@@ -2,8 +2,7 @@ import * as Redux from 'redux';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableState } from '../../PredefinedConfig/AdaptableState';
 import { ConfigState } from '../../PredefinedConfig/ConfigState';
-import { PredefinedConfig } from '../../PredefinedConfig/PredefinedConfig';
-import { IAdaptableStore } from './Interface/IAdaptableStore';
+import { IAdaptableStore, LoadStoreConfig } from './Interface/IAdaptableStore';
 type EmitterCallback = (data?: any) => any;
 type EmitterAnyCallback = (eventName: string, data?: any) => any;
 export declare const INIT_STATE = "INIT_STATE";
@@ -22,7 +21,6 @@ export declare const LoadState: (State: {
     [s: string]: ConfigState;
 }) => LoadStateAction;
 export declare class AdaptableStore implements IAdaptableStore {
-    private isAgGridReady;
     TheStore: Redux.Store<AdaptableState>;
     Load: Promise<any>;
     private emitter;
@@ -36,12 +34,12 @@ export declare class AdaptableStore implements IAdaptableStore {
     /**
      *
      * @param adaptable The Adaptable instance
-     * @param isAgGridReady A promise which is resolved when AG Grid is ready for binding
+     * @param postLoadHook A function that hydrates the state after it has been loaded from storage
      */
-    constructor(adaptable: IAdaptable, isAgGridReady: Promise<any>);
+    constructor(adaptable: IAdaptable);
     destroy(): void;
     getCurrentStorageState(): AdaptableState;
     saveStateNow(adaptable: IAdaptable): Promise<any>;
-    loadStore: (adaptable: IAdaptable, adaptableStateKey: string, predefinedConfig?: PredefinedConfig) => Promise<any>;
+    loadStore: (config: LoadStoreConfig) => Promise<any>;
 }
 export {};

package/src/Redux/Store/AdaptableStore.js

@@ -51,9 +51,9 @@ const TeamSharingState_1 = require("../../PredefinedConfig/TeamSharingState");
 exports.INIT_STATE = 'INIT_STATE';
 exports.LOAD_STATE = 'LOAD_STATE';
 const NON_PERSIST_ACTIONS = {
-    [exports.LOAD_STATE]: true,
     '@@INIT': true,
     '@@redux/init': true,
+    [exports.LOAD_STATE]: true,
     [exports.INIT_STATE]: true,
     // progress indicators should NOT interfere with state management as it may lead to race conditions due to load/persist state being async
     [SystemRedux_1.SYSTEM_PROGRESS_INDICATOR_SHOW]: true,
@@ -72,13 +72,12 @@ class AdaptableStore {
     /**
      *
      * @param adaptable The Adaptable instance
-     * @param isAgGridReady A promise which is resolved when AG Grid is ready for binding
+     * @param postLoadHook A function that hydrates the state after it has been loaded from storage
      */
-    constructor(adaptable, isAgGridReady) {
+    constructor(adaptable) {
         /*
           This is the main store for Adaptable State
         */
-        this.isAgGridReady = isAgGridReady;
         this.loadStorageInProgress = false;
         this.loadStateOnStartup = true; // set to false if you want no state
         this.on = (eventName, callback) => {
@@ -90,7 +89,9 @@ class AdaptableStore {
         this.emit = (eventName, data) => {
             return this.emitter.emit(eventName, data);
         };
-        this.loadStore = (adaptable, adaptableStateKey, predefinedConfig) => {
+        this.loadStore = (config) => {
+            const { adaptable, adaptableStateKey, predefinedConfig, postLoadHook } = config;
+            const postProcessState = postLoadHook !== null && postLoadHook !== void 0 ? postLoadHook : ((state) => state);
             this.storageEngine.setStateKey(adaptableStateKey);
             // START STATE LOAD
             this.loadStorageInProgress = true;
@@ -98,17 +99,15 @@ class AdaptableStore {
                 .load(predefinedConfig)
                 .then((storedState) => {
                 if (storedState && this.loadStateOnStartup) {
-                    this.TheStore.dispatch((0, exports.LoadState)(adaptable.adaptableOptions.stateOptions.applyState(storedState)));
+                    this.TheStore.dispatch((0, exports.LoadState)(postProcessState(adaptable.adaptableOptions.stateOptions.applyState(storedState))));
                 }
             })
-                // we need AG Grid to be ready because several states(ex. Layout) depend on its API
-                .then(() => this.isAgGridReady)
                 .then(() => {
                 this.TheStore.dispatch((0, exports.InitState)());
                 // END STATE LOAD
                 this.loadStorageInProgress = false;
             }, (e) => {
-                adaptable.logger.error('Failed to load previous Adaptable State : ', e);
+                adaptable.logger.consoleError('Failed to load previous Adaptable State : ', e);
                 //for now i'm still initializing Adaptable even if loading state has failed....
                 //we may revisit that later
                 this.TheStore.dispatch((0, exports.InitState)());
@@ -166,17 +165,6 @@ class AdaptableStore {
                 case exports.LOAD_STATE:
                     const { State } = action;
                     Object.keys(State).forEach((key) => {
-                        // this check should be removed in version 12 !!!
-                        if (key === 'Chart') {
-                            adaptable.logger.consoleWarn(`DEPRECATED: AdapTable Charts Plugin is deprecated! AG Grid built-in charts are fully supported & integrated in AdapTable.
-
-            Please contact 'support@adaptabletools.com' if you require any charting features that are not currently available.`);
-                        }
-                        if (key === 'SparklineColumn') {
-                            adaptable.logger.consoleWarn(`DEPRECATED: AdapTable SparklineColumn is deprecated! AG Grid built-in Sparklines are fully supported & integrated in AdapTable.
-
-            Please contact 'support@adaptabletools.com' if you require any sparklines features that are not currently available.`);
-                        }
                         state[key] = State[key];
                     });
                     break;
@@ -257,7 +245,6 @@ class AdaptableStore {
         ...pluginsMiddleware // the plugins middleware
         )));
         this.storageEngine = storageEngine;
-        this.loadStore(adaptable, adaptable.adaptableOptions.adaptableStateKey);
     }
     destroy() {
         var _a;
@@ -345,7 +332,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 }
                 case SystemRedux.SYSTEM_FLASHING_CELL_DELETE_ALL: {
                     let ret = next(action);
-                    adaptable.redrawRenderedRows();
+                    adaptable.redrawBody();
                     return ret;
                 }
                 /*******************
@@ -401,7 +388,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         });
                     }
                     // called also for rendered column actions, see RENDERED COLUMN ACTIONS block
-                    adaptable.setupColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /*******************
@@ -416,7 +403,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case FlashingCellRedux.FLASHING_CELL_DEFINITION_SUSPEND_ALL: {
                     const returnAction = next(action);
                     // called also for rendered column actions, see RENDERED COLUMN ACTIONS block
-                    adaptable.setupColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /**
@@ -581,11 +568,6 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 /*******************
                  * SPECIAL COLUMN ACTIONS
                  *******************/
-                case CalculatedColumnRedux.CALCULATED_COLUMN_READY: {
-                    // create aggregated scalar columns at grid startup
-                    adaptable.api.calculatedColumnApi.refreshAggregatedCalculatedColumns();
-                    return;
-                }
                 /**
                  * Use Case: We have added / edited / deleted a Special Column (i.e. one not in initial ColumnDefs)
                  * Action: We update the Special ColumnDefs
@@ -603,7 +585,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                             .createAggregatedScalarLiveValue(returnAction.calculatedColumn);
                         adaptable.api.calculatedColumnApi.internalApi.fireCalculatedColumnChangedEvent(action.type, actionTyped.calculatedColumn);
                     }
-                    adaptable.updateColDefsForSpecialColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /**
@@ -628,7 +610,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         .getCalculatedColumnExpressionService()
                         .destroyAggregatedScalarLiveValue(returnAction.calculatedColumn);
                     adaptable.api.calculatedColumnApi.internalApi.fireCalculatedColumnChangedEvent(action.type, actionTyped.calculatedColumn);
-                    adaptable.updateColDefsForSpecialColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /**
@@ -649,7 +631,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         return;
                     }
                     const returnAction = next(action);
-                    adaptable.updateColDefsForSpecialColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /*******************
@@ -686,7 +668,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case CustomSortRedux.CUSTOM_SORT_UNSUSPEND_ALL: {
                     const returnAction = next(action);
                     // called also for alert actions, see ALERT ACTIONS block
-                    adaptable.setupColumns();
+                    adaptable.updateColumnModelAndRefreshGrid();
                     return returnAction;
                 }
                 /*******************
@@ -1663,24 +1645,14 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                  *******************/
                 case exports.INIT_STATE: {
                     let returnAction = next(action);
-                    if (adaptable.isDestroyed) {
-                        return returnAction;
-                    }
-                    // make sure we have the grid columns in state, before we do any layout work
-                    adaptable.updateColumnsIntoStore();
-                    const layoutState = middlewareAPI.getState().Layout;
-                    const defaultLayout = adaptable.api.layoutApi.internalApi.createDefaultLayoutIfNeeded();
-                    let currentLayout = (layoutState === null || layoutState === void 0 ? void 0 : layoutState.CurrentLayout) || (defaultLayout === null || defaultLayout === void 0 ? void 0 : defaultLayout.Name);
-                    if (!adaptable.api.layoutApi.getLayoutByName(currentLayout)) {
-                        currentLayout = defaultLayout ? defaultLayout.Name : layoutState.Layouts[0].Name;
+                    if (adaptable.isReady) {
+                        // TODO see #create-create-module-menu
+                        // create the module menu (for use in the dashboard and the toolpanel)
+                        // we need this here for when the state key is changed
+                        // since we need the transient state to be restored in the same
+                        // way as when Adaptable is initialised.
+                        adaptable.ModuleService.createModuleMenus();
                     }
-                    middlewareAPI.dispatch(LayoutRedux.LayoutSelect(currentLayout));
-                    // do this now so it sets module entitlements
-                    adaptable.EntitlementService.setModulesEntitlements();
-                    // create the module menu (for use in the dashboard and the toolpanel)
-                    adaptable.ModuleService.createModuleMenus();
-                    // update initial mode of DataChangeHistory
-                    adaptable.api.internalApi.initializeDataChangeHistory();
                     return returnAction;
                 }
                 default: {

package/src/Redux/Store/Interface/IAdaptableStore.d.ts

@@ -2,10 +2,16 @@ import * as Redux from 'redux';
 import { AdaptableState } from '../../../PredefinedConfig/AdaptableState';
 import { PredefinedConfig } from '../../../types';
 import { IAdaptable } from '../../../AdaptableInterfaces/IAdaptable';
+export interface LoadStoreConfig {
+    adaptable: IAdaptable;
+    adaptableStateKey: string;
+    predefinedConfig?: PredefinedConfig;
+    postLoadHook?: (state: AdaptableState) => AdaptableState;
+}
 export interface IAdaptableStore {
     TheStore: Redux.Store<AdaptableState>;
     Load: PromiseLike<any>;
-    loadStore: (adaptable: IAdaptable, adaptableStateKey: string, predefinedConfig?: PredefinedConfig) => PromiseLike<any>;
+    loadStore: (config: LoadStoreConfig) => PromiseLike<any>;
     getCurrentStorageState: () => AdaptableState | void;
     saveStateNow: (adaptable: IAdaptable) => Promise<any>;
     on: (eventName: string, callback: (data?: any) => any) => () => void;