@adaptabletools/adaptable 10.0.0-canary.0

package/src/Redux/Store/AdaptableStore.js

@@ -0,0 +1,1258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableStore = exports.LoadState = exports.InitState = exports.LOAD_STATE = exports.INIT_STATE = void 0;
+const tslib_1 = require("tslib");
+const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+const Redux = tslib_1.__importStar(require("redux"));
+const AdaptableReduxLocalStorageEngine_1 = require("./AdaptableReduxLocalStorageEngine");
+const AdaptableReduxMerger_1 = require("./AdaptableReduxMerger");
+const PopupRedux = tslib_1.__importStar(require("../ActionsReducers/PopupRedux"));
+const PluginsRedux = tslib_1.__importStar(require("../ActionsReducers/PluginsRedux"));
+const AlertRedux = tslib_1.__importStar(require("../ActionsReducers/AlertRedux"));
+const DeadRedux = tslib_1.__importStar(require("../DeadRedux"));
+const SmartEditRedux = tslib_1.__importStar(require("../ActionsReducers/SmartEditRedux"));
+const BulkUpdateRedux = tslib_1.__importStar(require("../ActionsReducers/BulkUpdateRedux"));
+const CustomSortRedux = tslib_1.__importStar(require("../ActionsReducers/CustomSortRedux"));
+const CalculatedColumnRedux = tslib_1.__importStar(require("../ActionsReducers/CalculatedColumnRedux"));
+const ShortcutRedux = tslib_1.__importStar(require("../ActionsReducers/ShortcutRedux"));
+const GridRedux = tslib_1.__importStar(require("../ActionsReducers/GridRedux"));
+const SystemRedux = tslib_1.__importStar(require("../ActionsReducers/SystemRedux"));
+const PlusMinusRedux = tslib_1.__importStar(require("../ActionsReducers/PlusMinusRedux"));
+const ExportRedux = tslib_1.__importStar(require("../ActionsReducers/ExportRedux"));
+const ConditionalStyleRedux = tslib_1.__importStar(require("../ActionsReducers/ConditionalStyleRedux"));
+const QuickSearchRedux = tslib_1.__importStar(require("../ActionsReducers/QuickSearchRedux"));
+const DataSourceRedux = tslib_1.__importStar(require("../ActionsReducers/DataSourceRedux"));
+const FilterRedux = tslib_1.__importStar(require("../ActionsReducers/FilterRedux"));
+const ThemeRedux = tslib_1.__importStar(require("../ActionsReducers/ThemeRedux"));
+const FormatColumnRedux = tslib_1.__importStar(require("../ActionsReducers/FormatColumnRedux"));
+const ApplicationRedux = tslib_1.__importStar(require("../ActionsReducers/ApplicationRedux"));
+const SparklineColumnRedux = tslib_1.__importStar(require("../ActionsReducers/SparklineColumnRedux"));
+const FreeTextColumnRedux = tslib_1.__importStar(require("../ActionsReducers/FreeTextColumnRedux"));
+const LayoutRedux = tslib_1.__importStar(require("../ActionsReducers/LayoutRedux"));
+const DashboardRedux = tslib_1.__importStar(require("../ActionsReducers/DashboardRedux"));
+const ToolPanelRedux = tslib_1.__importStar(require("../ActionsReducers/ToolPanelRedux"));
+const ScheduleRedux = tslib_1.__importStar(require("../ActionsReducers/ScheduleRedux"));
+const TeamSharingRedux = tslib_1.__importStar(require("../ActionsReducers/TeamSharingRedux"));
+const QueryRedux = tslib_1.__importStar(require("../ActionsReducers/QueryRedux"));
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ConfigConstants = tslib_1.__importStar(require("../../Utilities/Constants/ConfigConstants"));
+const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
+const ObjectFactory_1 = require("../../Utilities/ObjectFactory");
+const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+const PreviewHelper_1 = require("../../Utilities/Helpers/PreviewHelper");
+const StringExtensions_1 = require("../../Utilities/Extensions/StringExtensions");
+const Emitter_1 = tslib_1.__importDefault(require("../../Utilities/Emitter"));
+const AdaptableToaster_1 = require("../../View/Components/Popups/AdaptableToaster");
+exports.INIT_STATE = 'INIT_STATE';
+exports.LOAD_STATE = 'LOAD_STATE';
+const NON_PERSIST_ACTIONS = {
+    [exports.LOAD_STATE]: true,
+    '@@INIT': true,
+    '@@redux/init': true,
+    [exports.INIT_STATE]: true,
+};
+exports.InitState = () => ({
+    type: exports.INIT_STATE,
+});
+exports.LoadState = (State) => ({
+    type: exports.LOAD_STATE,
+    State,
+});
+class AdaptableStore {
+    /**
+     *
+     * @param adaptable The Adaptable instance
+     * @param isVendorReady A promise which is resolved when the underlying grid is ready for binding
+     */
+    constructor(adaptable, isVendorReady) {
+        /*
+    This is the main store for Adaptable State
+    */
+        this.isVendorReady = isVendorReady;
+        this.loadStorageInProgress = false;
+        this.loadStartOnStartup = true; // set to false if you want no state
+        this.on = (eventName, callback) => {
+            return this.emitter.on(eventName, callback);
+        };
+        this.onAny = (callback) => {
+            return this.emitter.onAny(callback);
+        };
+        this.emit = (eventName, data) => {
+            return this.emitter.emit(eventName, data);
+        };
+        this.loadStore = (adaptable, adaptableStateKey, predefinedConfig) => {
+            this.storageEngine.setStateKey(adaptableStateKey);
+            // START STATE LOAD
+            this.loadStorageInProgress = true;
+            return (this.Load = this.storageEngine
+                .load(predefinedConfig)
+                .then((storedState) => {
+                if (storedState && this.loadStartOnStartup) {
+                    this.TheStore.dispatch(exports.LoadState(adaptable.adaptableOptions.stateOptions.applyState(storedState)));
+                }
+            })
+                // we need the vendor grid to be ready because several states(ex. Layout) depend on its API
+                .then(() => this.isVendorReady)
+                .then(() => {
+                this.TheStore.dispatch(exports.InitState());
+                // END STATE LOAD
+                this.loadStorageInProgress = false;
+            }, (e) => {
+                LoggingHelper_1.LogAdaptableError('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(exports.InitState());
+                // END STATE LOAD
+                this.loadStorageInProgress = false;
+                this.TheStore.dispatch(PopupRedux.PopupShowAlert({
+                    header: 'Configuration',
+                    message: 'Error loading your configuration:' + e,
+                    alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                }));
+            }));
+        };
+        let rootReducerObject = {
+            //  Reducers for Non-Persisted State
+            Grid: GridRedux.GridReducer,
+            Popup: PopupRedux.PopupReducer,
+            System: SystemRedux.SystemReducer,
+            Plugins: PluginsRedux.PluginsReducer,
+            SparklineColumn: SparklineColumnRedux.SparklineColumnReducer,
+            // Reducers for Persisted State
+            Alert: AlertRedux.AlertReducer,
+            Application: ApplicationRedux.ApplicationReducer,
+            CalculatedColumn: CalculatedColumnRedux.CalculatedColumnReducer,
+            // replaced by `charts` plugin
+            Chart: (state) => {
+                return state !== null && state !== void 0 ? state : null;
+            },
+            ConditionalStyle: ConditionalStyleRedux.ConditionalStyleReducer,
+            CustomSort: CustomSortRedux.CustomSortReducer,
+            Dashboard: DashboardRedux.DashboardReducer,
+            DataSource: DataSourceRedux.DataSourceReducer,
+            Export: ExportRedux.ExportReducer,
+            Filter: FilterRedux.FilterReducer,
+            FormatColumn: FormatColumnRedux.FormatColumnReducer,
+            FreeTextColumn: FreeTextColumnRedux.FreeTextColumnReducer,
+            Layout: LayoutRedux.LayoutReducer,
+            Schedule: ScheduleRedux.ScheduleReducer,
+            PlusMinus: PlusMinusRedux.PlusMinusReducer,
+            QuickSearch: QuickSearchRedux.QuickSearchReducer,
+            Shortcut: ShortcutRedux.ShortcutReducer,
+            TeamSharing: TeamSharingRedux.TeamSharingReducer,
+            Theme: ThemeRedux.ThemeReducer,
+            ToolPanel: ToolPanelRedux.ToolPanelReducer,
+            Query: QueryRedux.QueryReducer,
+            // dead reducers
+            PercentBar: DeadRedux.PercentBarReducer,
+            FlashingCell: DeadRedux.FlashingCellReducer,
+            UpdatedRow: DeadRedux.UpdatedRowReducer,
+            GradientColumn: DeadRedux.GradientColumnReducer,
+        };
+        // allow plugins to participate in the root reducer
+        adaptable.forPlugins((plugin) => {
+            if (plugin.rootReducer) {
+                rootReducerObject = Object.assign(Object.assign({}, rootReducerObject), plugin.rootReducer(rootReducerObject));
+            }
+        });
+        const initialRootReducer = Redux.combineReducers(rootReducerObject);
+        const rootReducerWithResetManagement = (state, action) => {
+            switch (action.type) {
+                case exports.LOAD_STATE:
+                    const { State } = action;
+                    Object.keys(State).forEach((key) => {
+                        state[key] = State[key];
+                    });
+                    break;
+            }
+            return initialRootReducer(state, action);
+        };
+        let storageEngine;
+        this.emitter = new Emitter_1.default();
+        // If the user has remote storage set then we use Remote Engine, otherwise we use Local Enginge
+        // not sure we can do this as we need to be backwardly compatible with existing users so need to stick with adaptable id (which should be unique)
+        // const localStorageKey =  'adaptable-adaptable-state-' + adaptable.adaptableOptions.primaryKey;
+        storageEngine = AdaptableReduxLocalStorageEngine_1.createEngine({
+            adaptableId: adaptable.adaptableOptions.adaptableId,
+            adaptableStateKey: adaptable.adaptableOptions.adaptableStateKey,
+            userName: adaptable.adaptableOptions.userName,
+            predefinedConfig: adaptable.adaptableOptions.predefinedConfig,
+            loadState: adaptable.adaptableOptions.stateOptions.loadState,
+            persistState: adaptable.adaptableOptions.stateOptions.persistState,
+            debounceStateDelay: adaptable.adaptableOptions.stateOptions.debounceStateDelay,
+        });
+        const nonPersistentReduxKeys = [
+            // Non Persisted State
+            ConfigConstants.SYSTEM,
+            ConfigConstants.GRID,
+            ConfigConstants.POPUP,
+            ConfigConstants.PLUGINS,
+            ConfigConstants.SPARKLINE_COLUMN,
+        ];
+        // this is now VERY BADLY NAMED!
+        let rootReducer = AdaptableReduxMerger_1.mergeReducer(rootReducerWithResetManagement, exports.LOAD_STATE);
+        const composeEnhancers = (x) => x;
+        const persistedReducer = (state, action) => {
+            var _a, _b;
+            const init = state === undefined;
+            const newState = rootReducer(state, action);
+            // ideally the reducer should be pure,
+            // but having the emitter emit the event here
+            // is really useful
+            const emitterArg = { action, state, newState };
+            this.emitter.emit(action.type, emitterArg);
+            const finalState = emitterArg.newState;
+            const shouldPersist = !((_b = (_a = state === null || state === void 0 ? void 0 : state.System) === null || _a === void 0 ? void 0 : _a.License) === null || _b === void 0 ? void 0 : _b.disablePersistence) &&
+                !NON_PERSIST_ACTIONS[action.type] &&
+                !init &&
+                !this.loadStorageInProgress;
+            if (shouldPersist) {
+                const storageState = Object.assign({}, finalState);
+                nonPersistentReduxKeys.forEach((key) => {
+                    delete storageState[key];
+                });
+                this.currentStorageState = storageState;
+                storageEngine.save(storageState, adaptable.adaptableOptions.stateOptions.saveState);
+            }
+            return finalState;
+        };
+        const pluginsMiddleware = [];
+        adaptable.forPlugins((plugin) => {
+            if (plugin.reduxMiddleware) {
+                pluginsMiddleware.push(plugin.reduxMiddleware(adaptable));
+            }
+        });
+        //TODO: need to check if we want the storage to be done before or after
+        //we enrich the state with the AB middleware
+        this.TheStore = Redux.createStore(persistedReducer, composeEnhancers(Redux.applyMiddleware(adaptableMiddleware(adaptable), // the main middleware that actually does stuff,
+        ...pluginsMiddleware // the plugins middleware
+        )));
+        this.storageEngine = storageEngine;
+        this.loadStore(adaptable, adaptable.adaptableOptions.adaptableStateKey);
+    }
+    getCurrentStorageState() {
+        return this.currentStorageState;
+    }
+    saveStateNow(adaptable) {
+        const storageState = this.getCurrentStorageState();
+        if (storageState) {
+            return this.storageEngine.saveNow(storageState, adaptable.adaptableOptions.stateOptions.saveState);
+        }
+        return Promise.resolve(true);
+    }
+}
+exports.AdaptableStore = AdaptableStore;
+// this is the main function for dealing with Redux Actions which require additional functionality to be triggered.
+// Please document each use case where we have to use the Store rather than a module or a popup screen
+// This should ideally be the ONLY place where we LISTEN to store changes
+const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
+    return function (next) {
+        return function (action) {
+            var _a, _b, _c, _d, _e;
+            switch (action.type) {
+                /*******************
+                 * NAMED QUERY ACTIONS
+                 *******************/
+                /**
+                 * Use Case: User has deleted a Named Query
+                 * Action: Check whether it is referenced elsewhere before deleting
+                 */
+                case QueryRedux.NAMED_QUERY_DELETE: {
+                    const actionTyped = action;
+                    // check if Named Query is not referenced elsewhere
+                    const namedQueryReferences = adaptable.api.queryApi.getNamedQueryModuleReferences(actionTyped.namedQuery.Name);
+                    if (namedQueryReferences.length) {
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Named Query could not be deleted',
+                            message: `It is still referenced in the following modules: ${namedQueryReferences.join(', ')}`,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                        return;
+                    }
+                    const ret = next(action);
+                    return ret;
+                }
+                case QueryRedux.NAMED_QUERY_EDIT: {
+                    const actionTyped = action;
+                    // check if name was changed, in which case we have to check if it's referenced
+                    const editedNamedQuery = actionTyped.namedQuery;
+                    const previousNamedQueryName = (_b = (_a = middlewareAPI
+                        .getState()
+                        .Query.NamedQueries.find((namedQuery) => namedQuery.Uuid === editedNamedQuery.Uuid)) === null || _a === void 0 ? void 0 : _a.Name) !== null && _b !== void 0 ? _b : '';
+                    if (editedNamedQuery.Name !== previousNamedQueryName) {
+                        // if query is referenced elsewhere we cannot allow the name change, as it would turn the referents invalid
+                        const namedQueryReferences = adaptable.api.queryApi.getNamedQueryModuleReferences(previousNamedQueryName);
+                        if (namedQueryReferences.length) {
+                            middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                                header: 'Named Query could not be renamed',
+                                message: `It is currently referenced in the following modules: ${namedQueryReferences.join(', ')}`,
+                                alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                            }));
+                            return;
+                        }
+                    }
+                    const ret = next(action);
+                    return ret;
+                }
+                /**
+                 * Use Case: Query has changed
+                 * Action: Filter the Grid and fire SearchChangedEvent
+                 */
+                case QueryRedux.QUERY_RUN: {
+                    let ret = next(action);
+                    setTimeout(() => adaptable.applyGridFiltering(), 5);
+                    adaptable.api.gridApi.fireSearchChangedEvent('CurrentQuery');
+                    return ret;
+                }
+                /*******************
+                 * FLASHING ALERT ACTIONS
+                 *******************/
+                case SystemRedux.SYSTEM_FLASHING_ALERT_ADD:
+                case SystemRedux.SYSTEM_FLASHING_ALERT_DELETE: {
+                    const { flashingAlert: FlashingAlert, } = action;
+                    const { dataChangedInfo } = FlashingAlert;
+                    let ret = next(action);
+                    if (dataChangedInfo) {
+                        adaptable.refreshCells([dataChangedInfo.rowNode], Object.keys(FlashingAlert.flashColumnIds), true);
+                    }
+                    return ret;
+                }
+                /*******************
+                 * ALERT ACTIONS
+                 *******************/
+                case AlertRedux.ALERT_READY: {
+                    // create observable alerts at grid startup
+                    const reactiveAlertDefinitions = adaptable.api.alertApi.getActiveReactiveAlertDefinitions();
+                    reactiveAlertDefinitions.forEach((reactiveAlertDefinition) => adaptable.api.internalApi
+                        .getAlertService()
+                        .createReactiveAlert(reactiveAlertDefinition));
+                    const reactiveFlashingAlertDefinitions = adaptable.api.alertApi.getActiveReactiveFlashingAlertDefinitions();
+                    reactiveFlashingAlertDefinitions.forEach((reactiveAlertDefinition) => adaptable.api.internalApi
+                        .getAlertService()
+                        .createReactiveAlert(reactiveAlertDefinition, true));
+                    return;
+                }
+                case AlertRedux.ALERT_DEFINITION_ADD:
+                case AlertRedux.ALERT_DEFINITION_EDIT:
+                case AlertRedux.ALERT_DEFINITION_DELETE:
+                case AlertRedux.FLASHING_ALERT_DEFINITION_ADD:
+                case AlertRedux.FLASHING_ALERT_DEFINITION_EDIT:
+                case AlertRedux.FLASHING_ALERT_DEFINITION_DELETE:
+                case AlertRedux.ALERT_DEFINITION_UN_SUSPEND:
+                case AlertRedux.ALERT_DEFINITION_SUSPEND:
+                case AlertRedux.FLASHING_ALERT_DEFINITION_UN_SUSPEND:
+                case AlertRedux.FLASHING_ALERT_DEFINITION_SUSPEND: {
+                    const returnAction = next(action);
+                    const isFlashingAlert = returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_ADD ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_EDIT ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_DELETE ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_SUSPEND ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_UN_SUSPEND;
+                    const alertDefinition = isFlashingAlert
+                        ? returnAction.flashingAlertDefinition
+                        : returnAction.alertDefinition;
+                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_ADD ||
+                        returnAction.type === AlertRedux.ALERT_DEFINITION_EDIT ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_ADD ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_EDIT ||
+                        returnAction.type === AlertRedux.ALERT_DEFINITION_UN_SUSPEND ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_UN_SUSPEND) {
+                        // in case of edit, the existing reactive alert will be deleted and recreated
+                        adaptable.api.internalApi
+                            .getAlertService()
+                            .createReactiveAlert(alertDefinition, isFlashingAlert);
+                    }
+                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_DELETE ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_DELETE ||
+                        returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND ||
+                        returnAction.type === AlertRedux.FLASHING_ALERT_DEFINITION_SUSPEND) {
+                        adaptable.api.internalApi.getAlertService().deleteReactiveAlert(alertDefinition);
+                    }
+                    // called also for rendered column actions, see RENDERED COLUMN ACTIONS block
+                    adaptable.setupColumns();
+                    return returnAction;
+                }
+                /**
+                 * Use Case: User has deleted a System Alert which has a Highlight Cell
+                 * Action: Refresh the cell (to clear the style)
+                 */
+                case SystemRedux.SYSTEM_ALERT_DELETE: {
+                    const actionTyped = action;
+                    let ret = next(action);
+                    if (((_c = actionTyped.alert.alertDefinition.AlertProperties) === null || _c === void 0 ? void 0 : _c.HighlightCell) &&
+                        actionTyped.alert.dataChangedInfo) {
+                        let rowNode = actionTyped.alert.dataChangedInfo.rowNode;
+                        adaptable.refreshCells([rowNode], [actionTyped.alert.dataChangedInfo.columnId], true);
+                    }
+                    return ret;
+                }
+                /**
+                 * Use Case: User has deleted all System Alerts some of which have a Highlight Cell
+                 * Action: Refresh the cell (to clear the style)
+                 */
+                case SystemRedux.SYSTEM_ALERT_DELETE_ALL: {
+                    const actionTyped = action;
+                    let ret = next(action);
+                    let alerts = actionTyped.alerts;
+                    alerts.forEach((alert) => {
+                        var _a;
+                        if (((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightCell) && alert.dataChangedInfo) {
+                            let rowNode = alert.dataChangedInfo.rowNode;
+                            adaptable.refreshCells([rowNode], [alert.dataChangedInfo.columnId], true);
+                        }
+                    });
+                    return ret;
+                }
+                /**
+                 * Use Case: A System Alert had a Highlight Cell with a limited duration
+                 * Action: Refresh the cell (to clear the style)
+                 */
+                case SystemRedux.SYSTEM_ALERT_REMOVE_HIGHLIGHT: {
+                    const actionTyped = action;
+                    let ret = next(action);
+                    if (actionTyped.alert.dataChangedInfo) {
+                        let rowNode = actionTyped.alert.dataChangedInfo.rowNode;
+                        adaptable.refreshCells([rowNode], [actionTyped.alert.dataChangedInfo.columnId], true);
+                    }
+                    return ret;
+                }
+                case SystemRedux.SYSTEM_HIGHLIGHT_CELL_ADD: {
+                    const actionTyped = action;
+                    const ret = next(action);
+                    const cellHighlightInfo = actionTyped.cellHighlightInfo;
+                    const rowNode = adaptable.getRowNodeForPrimaryKey(cellHighlightInfo.primaryKeyValue);
+                    if (rowNode) {
+                        adaptable.refreshCells([rowNode], [cellHighlightInfo.columnId], true);
+                    }
+                    return ret;
+                }
+                case SystemRedux.SYSTEM_HIGHLIGHT_CELL_DELETE: {
+                    const actionTyped = action;
+                    const ret = next(action);
+                    const cellHighlightInfo = actionTyped.cellHighlightInfo;
+                    const rowNode = adaptable.getRowNodeForPrimaryKey(cellHighlightInfo.primaryKeyValue);
+                    if (rowNode) {
+                        adaptable.refreshCells([rowNode], [cellHighlightInfo.columnId], true);
+                    }
+                    return ret;
+                }
+                case SystemRedux.SYSTEM_HIGHLIGHT_CELL_DELETE_ALL: {
+                    const cellHighlightInfos = middlewareAPI.getState().System.HighlightedCells;
+                    const ret = next(action);
+                    cellHighlightInfos.forEach((cellHighlightInfo) => {
+                        const rowNode = adaptable.getRowNodeForPrimaryKey(cellHighlightInfo.primaryKeyValue);
+                        if (!rowNode) {
+                            return;
+                        }
+                        adaptable.refreshCells([rowNode], [cellHighlightInfo.columnId], true);
+                    });
+                    return ret;
+                }
+                /*******************
+                 * SPECIAL COLUMN ACTIONS
+                 *******************/
+                /**
+                 * Use Case: We have added / edited / deleted a Special Column (i.e. one not in initial ColumnDefs)
+                 * Action: We update the Special ColumnDefs
+                 */
+                case FreeTextColumnRedux.FREE_TEXT_COLUMN_ADD:
+                case FreeTextColumnRedux.FREE_TEXT_COLUMN_EDIT:
+                case CalculatedColumnRedux.CALCULATED_COLUMN_ADD:
+                case CalculatedColumnRedux.CALCULATED_COLUMN_EDIT: {
+                    const returnAction = next(action);
+                    adaptable.updateColDefsForSpecialColumns();
+                    return returnAction;
+                }
+                /**
+                 * Use Case: We have deleted a CalculatedColumn (i.e. one not in initial ColumnDefs)
+                 * Action: Check whether it is referenced elsewhere before deleting then update the Special ColumnDefs
+                 */
+                case CalculatedColumnRedux.CALCULATED_COLUMN_DELETE: {
+                    const actionTyped = action;
+                    // check if CalculatedColumn is not referenced elsewhere
+                    const calculatedColumnReferences = adaptable.api.calculatedColumnApi.getCalculatedColumnModuleReferences(actionTyped.calculatedColumn);
+                    if (calculatedColumnReferences.length) {
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'CalculatedColumn could not be deleted',
+                            message: `It is still referenced in the following modules: ${calculatedColumnReferences.join(', ')}`,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                        return;
+                    }
+                    const returnAction = next(action);
+                    adaptable.updateColDefsForSpecialColumns();
+                    return returnAction;
+                }
+                /**
+                 * Use Case: We have deleted a FreeText Column (i.e. one not in initial ColumnDefs)
+                 * Action: Check whether it is referenced elsewhere before deleting then update the Special ColumnDefs
+                 */
+                case FreeTextColumnRedux.FREE_TEXT_COLUMN_DELETE: {
+                    const actionTyped = action;
+                    // check if FreeTextColumn is not referenced elsewhere
+                    const freeTextColumnReferences = adaptable.api.freeTextColumnApi.getFreeTextColumnModuleReferences(actionTyped.freeTextColumn);
+                    if (freeTextColumnReferences.length) {
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'FreeTextColumn could not be deleted',
+                            message: `It is still referenced in the following modules: ${freeTextColumnReferences.join(', ')}`,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                        return;
+                    }
+                    const returnAction = next(action);
+                    adaptable.updateColDefsForSpecialColumns();
+                    return returnAction;
+                }
+                /*******************
+                 * RENDERED COLUMN ACTIONS
+                 *******************/
+                /**
+                 * Use Case: We have updated an AdapTable Module that affects rendering
+                 * Action: We set up all columns again
+                 */
+                case QuickSearchRedux.QUICK_SEARCH_SET_STYLE:
+                case SparklineColumnRedux.SPARKLINE_COLUMNS_ADD:
+                case SparklineColumnRedux.SPARKLINE_COLUMNS_EDIT:
+                case SparklineColumnRedux.SPARKLINE_COLUMNS_DELETE:
+                case FormatColumnRedux.FORMAT_COLUMN_ADD:
+                case FormatColumnRedux.FORMAT_COLUMN_EDIT:
+                case FormatColumnRedux.FORMAT_COLUMN_DELETE:
+                case FormatColumnRedux.FORMAT_COLUMN_SUSPEND:
+                case FormatColumnRedux.FORMAT_COLUMN_UN_SUSPEND:
+                case CustomSortRedux.CUSTOM_SORT_ADD:
+                case CustomSortRedux.CUSTOM_SORT_EDIT:
+                case CustomSortRedux.CUSTOM_SORT_DELETE:
+                case CustomSortRedux.CUSTOM_SORT_SUSPEND:
+                case CustomSortRedux.CUSTOM_SORT_UN_SUSPEND:
+                case ConditionalStyleRedux.CONDITIONAL_STYLE_ADD:
+                case ConditionalStyleRedux.CONDITIONAL_STYLE_EDIT:
+                case ConditionalStyleRedux.CONDITIONAL_STYLE_SUSPEND:
+                case ConditionalStyleRedux.CONDITIONAL_STYLE_UN_SUSPEND:
+                case ConditionalStyleRedux.CONDITIONAL_STYLE_DELETE: {
+                    const returnAction = next(action);
+                    // called also for alert actions, see ALERT ACTIONS block
+                    adaptable.setupColumns();
+                    return returnAction;
+                }
+                /*******************
+                 * QUICK SEARCH ACTIONS
+                 *******************/
+                /**
+                 * Use Case: User has run a Quick Search
+                 * Action1: Call Adaptable to redraw body so cells can be highlighted
+                 * Action2: Run Query using Quick Search text it set in Search Options
+                 */
+                case QuickSearchRedux.QUICK_SEARCH_RUN: {
+                    let returnAction = next(action);
+                    adaptable.redrawBody();
+                    // if set then reun a query on the text
+                    if (adaptable.adaptableOptions.searchOptions.runQueryAfterQuickSearch) {
+                        const actionTyped = action;
+                        const searchText = actionTyped.quickSearchText;
+                        if (StringExtensions_1.StringExtensions.IsNotNullOrEmpty(searchText)) {
+                            const queryText = 'ANY_CONTAINS("' + searchText + '") ';
+                            adaptable.api.queryApi.setCurrentQuery(queryText);
+                        }
+                        else {
+                            adaptable.api.queryApi.clearCurrentQuery();
+                        }
+                    }
+                    return returnAction;
+                }
+                /*******************
+                 * FILTER ACTIONS
+                 *******************/
+                case FilterRedux.QUICK_FILTER_BAR_SHOW: {
+                    adaptable.showQuickFilter();
+                    return next(action);
+                }
+                case FilterRedux.QUICK_FILTER_BAR_HIDE: {
+                    adaptable.hideQuickFilter();
+                    return next(action);
+                }
+                case FilterRedux.FILTER_FORM_HIDE: {
+                    adaptable.api.gridApi.hideFilterForm();
+                    return next(action);
+                }
+                /**
+                 * Use Case: Column Filters have changed
+                 * Action: Apply grid filtering and fire search changed event
+                 */
+                case FilterRedux.COLUMN_FILTER_ADD:
+                case FilterRedux.COLUMN_FILTER_EDIT:
+                case FilterRedux.COLUMN_FILTER_SET:
+                case FilterRedux.COLUMN_FILTER_CLEAR_ALL:
+                case FilterRedux.COLUMN_FILTER_CLEAR: {
+                    let returnAction = next(action);
+                    setTimeout(() => adaptable.applyGridFiltering(), 5);
+                    adaptable.api.gridApi.fireSearchChangedEvent('Filter');
+                    return returnAction;
+                }
+                /*******************
+                 * DATA SOURCE ACTIONS
+                 *******************/
+                /**
+                 * Use Case: Data Sources have been amended
+                 * Action: Fire search changed event
+                 */
+                case DataSourceRedux.DATA_SOURCE_SELECT:
+                case DataSourceRedux.DATA_SOURCE_ADD:
+                case DataSourceRedux.DATA_SOURCE_EDIT:
+                case DataSourceRedux.DATA_SOURCE_DELETE: {
+                    let returnAction = next(action);
+                    adaptable.api.gridApi.fireSearchChangedEvent('DataSource');
+                    return returnAction;
+                }
+                /*******************
+                 * THEME ACTIONS
+                 *******************/
+                /**
+                 * Use Case: Theme has changed
+                 * Action: Apply new Theme
+                 */
+                case ThemeRedux.THEME_SELECT: {
+                    let returnAction = next(action);
+                    adaptable.api.themeApi.applyCurrentTheme();
+                    return returnAction;
+                }
+                /*******************
+                 * SCHEDULE ACTIONS
+                 *******************/
+                /**
+                 * Use Case: Schedule has changed
+                 * Action: Set up ALL jobs
+                 */
+                case ScheduleRedux.REMINDER_SCHEDULE_ADD:
+                case ScheduleRedux.REMINDER_SCHEDULE_EDIT:
+                case ScheduleRedux.REMINDER_SCHEDULE_DELETE:
+                case ScheduleRedux.REMINDER_SCHEDULE_UN_SUSPEND:
+                case ScheduleRedux.REMINDER_SCHEDULE_SUSPEND:
+                case ScheduleRedux.REPORT_SCHEDULE_ADD:
+                case ScheduleRedux.REPORT_SCHEDULE_EDIT:
+                case ScheduleRedux.REPORT_SCHEDULE_DELETE:
+                case ScheduleRedux.REPORT_SCHEDULE_SUSPEND:
+                case ScheduleRedux.REPORT_SCHEDULE_UN_SUSPEND:
+                case ScheduleRedux.IPUSHPULL_SCHEDULE_ADD:
+                case ScheduleRedux.IPUSHPULL_SCHEDULE_EDIT:
+                case ScheduleRedux.IPUSHPULL_SCHEDULE_DELETE:
+                case ScheduleRedux.IPUSHPULL_SCHEDULE_SUSPEND:
+                case ScheduleRedux.IPUSHPULL_SCHEDULE_UN_SUSPEND:
+                case ScheduleRedux.GLUE42_SCHEDULE_ADD:
+                case ScheduleRedux.GLUE42_SCHEDULE_EDIT:
+                case ScheduleRedux.GLUE42_SCHEDULE_DELETE:
+                case ScheduleRedux.GLUE42_SCHEDULE_SUSPEND:
+                case ScheduleRedux.GLUE42_SCHEDULE_UN_SUSPEND:
+                case ScheduleRedux.OPENFIN_SCHEDULE_ADD:
+                case ScheduleRedux.OPENFIN_SCHEDULE_EDIT:
+                case ScheduleRedux.OPENFIN_SCHEDULE_DELETE:
+                case ScheduleRedux.OPENFIN_SCHEDULE_SUSPEND:
+                case ScheduleRedux.OPENFIN_SCHEDULE_UN_SUSPEND: {
+                    let returnAction = next(action);
+                    let module = adaptable.modules.get(ModuleConstants.ScheduleModuleId);
+                    module.setUpSechduleJobs();
+                    return returnAction;
+                }
+                /*******************
+                 * DASHBOARD ACTIONS
+                 *******************/
+                case DashboardRedux.DASHBOARD_SET_IS_COLLAPSED:
+                case DashboardRedux.DASHBOARD_SET_MODULE_BUTTONS:
+                case DashboardRedux.DASHBOARD_ACTIVE_TAB_INDEX_CHANGE:
+                case DashboardRedux.DASHBOARD_SET_IS_FLOATING:
+                case DashboardRedux.DASHBOARD_SET_IS_INLINE:
+                case DashboardRedux.DASHBOARD_SET_IS_HIDDEN:
+                case DashboardRedux.DASHBOARD_SET_FLOATING_POSITION:
+                case DashboardRedux.DASHBOARD_SET_TABS:
+                case DashboardRedux.DASHBOARD_CREATE_DEFAULT_TAB:
+                case DashboardRedux.DASHBOARD_CLOSE_TOOLBAR: {
+                    const oldDashboardState = middlewareAPI.getState().Dashboard;
+                    let returnAction = next(action);
+                    const newDashboardState = middlewareAPI.getState().Dashboard;
+                    adaptable.api.dashboardApi.fireDashboardChangedEvent(action.type, oldDashboardState, newDashboardState);
+                    return returnAction;
+                }
+                /*******************
+                 * LAYOUT ACTIONS
+                 *******************/
+                case LayoutRedux.LAYOUT_ADD:
+                case LayoutRedux.LAYOUT_EDIT:
+                case LayoutRedux.LAYOUT_SAVE:
+                case LayoutRedux.LAYOUT_DELETE:
+                case LayoutRedux.LAYOUT_SELECT: {
+                    const oldLayoutState = middlewareAPI.getState().Layout;
+                    let returnAction = next(action);
+                    const newLayoutState = middlewareAPI.getState().Layout;
+                    adaptable.api.layoutApi.fireLayoutChangedEvent(action.type, oldLayoutState, newLayoutState);
+                    if (returnAction.type == LayoutRedux.LAYOUT_SELECT ||
+                        returnAction.type == LayoutRedux.LAYOUT_DELETE) {
+                        let gridState = middlewareAPI.getState().Grid;
+                        let currentLayout = newLayoutState.Layouts.find((l) => l.Name == newLayoutState.CurrentLayout);
+                        if (gridState.CurrentLayout) {
+                            currentLayout = gridState.CurrentLayout;
+                        }
+                        if (currentLayout) {
+                            // tell grid the layout has been selected
+                            adaptable.setLayout(currentLayout);
+                        }
+                        if (!((_d = adaptable.adaptableOptions.layoutOptions) === null || _d === void 0 ? void 0 : _d.autoSaveLayouts)) {
+                            middlewareAPI.dispatch(LayoutRedux.LayoutUpdateCurrentDraft(currentLayout));
+                        }
+                    }
+                    if (returnAction.type == LayoutRedux.LAYOUT_ADD ||
+                        returnAction.type == LayoutRedux.LAYOUT_SAVE) {
+                        const actionTyped = action;
+                        // if autosave is false
+                        if (!((_e = adaptable.adaptableOptions.layoutOptions) === null || _e === void 0 ? void 0 : _e.autoSaveLayouts)) {
+                            // and the current layout is saved, make sure we also update the draft
+                            if (actionTyped.layout.Name === newLayoutState.CurrentLayout) {
+                                middlewareAPI.dispatch(LayoutRedux.LayoutUpdateCurrentDraft(actionTyped.layout));
+                            }
+                        }
+                    }
+                    return returnAction;
+                }
+                /*******************
+                 * SMART EDIT ACTIONS
+                 *******************/
+                /**
+                 * Use Case: User wants to perform Smart Edit and we need to check if the cell selection is valid
+                 * Action (1):  Get the result from the SmartEdit module
+                 * If the return is an Alert:
+                 * Action (2): If there is a popup open, close it and show the Alert; otherwise just set false valid selection
+                 * If the return is valid:
+                 * Action (2): Set the valid selection to true
+                 * Action (3): Build the Preview Values (via Smart Edit module)
+                 * Action (4): Set the Preview Values (this will populate the preview screen)
+                 */
+                case SystemRedux.SYSTEM_SMARTEDIT_CHECK_CELL_SELECTION: {
+                    let module = adaptable.modules.get(ModuleConstants.SmartEditModuleId);
+                    let state = middlewareAPI.getState();
+                    let returnAction = next(action);
+                    let apiReturn = module.CheckCorrectCellSelection();
+                    let popup = state.Popup.ScreenPopup;
+                    // this is a horrible hack and fix for a weird issue
+                    // we really need to do smart edit and bulk update better
+                    // but this fixes it for now
+                    if (popup.ComponentName != 'LayoutPopup') {
+                        if (apiReturn.Alert) {
+                            // check if Smart Edit is showing as popup and then close and show error (dont want to do that if from toolbar)
+                            if (popup.ComponentName == 'SmartEditPopup') {
+                                // We are in SmartEditPopup so let's close it
+                                middlewareAPI.dispatch(PopupRedux.PopupHideScreen());
+                                // and now show the alert Popup
+                                middlewareAPI.dispatch(PopupRedux.PopupShowAlert(apiReturn.Alert));
+                            }
+                            middlewareAPI.dispatch(SystemRedux.SmartEditSetValidSelection(false));
+                        }
+                        else {
+                            middlewareAPI.dispatch(SystemRedux.SmartEditSetValidSelection(true));
+                            let apiPreviewReturn = module.BuildPreviewValues(state.System.SmartEditValue, state.System.SmartEditOperation);
+                            middlewareAPI.dispatch(SystemRedux.SmartEditSetPreview(apiPreviewReturn));
+                        }
+                    }
+                    return returnAction;
+                }
+                /**
+                 * Use Case: User has changed a Smmart Edit property or requested a preview
+                 * Action (1):  Get the new preview set from the Smart Edit module
+                 * Action (2):  Set the Preview Values (this will populate the preview screen)
+                 */
+                case SystemRedux.SYSTEM_SMART_EDIT_CHANGE_OPERATION:
+                case SystemRedux.SYSTEM_SMART_EDIT_CHANGE_VALUE:
+                case SystemRedux.SYSTEM_SMARTEDIT_FETCH_PREVIEW: {
+                    //all our logic needs to be executed AFTER the main reducers
+                    //so our state is up to date which allow us not to care about the data within each different action
+                    let returnAction = next(action);
+                    let module = adaptable.modules.get(ModuleConstants.SmartEditModuleId);
+                    let state = middlewareAPI.getState();
+                    let apiReturn = module.BuildPreviewValues(state.System.SmartEditValue, state.System.SmartEditOperation);
+                    middlewareAPI.dispatch(SystemRedux.SmartEditSetPreview(apiReturn));
+                    return returnAction;
+                }
+                /**
+                 * Use Case: User has clicked 'Apply' in Smart Edit popup or toolbar
+                 * Action (1):  Gets the values that need to be applied from the Preview Info and passes to Preview Helper (incl. whether to bypass validation)
+                 * Action (2):  Sends these new values to the Smart Edit module (which will, in turn, apply them to Adaptable)
+                 */
+                case SmartEditRedux.SMART_EDIT_COMPLETE: {
+                    let module = adaptable.modules.get(ModuleConstants.SmartEditModuleId);
+                    const actionTyped = action;
+                    let thePreview = middlewareAPI.getState().System.SmartEditPreviewInfo;
+                    let newValues = PreviewHelper_1.PreviewHelper.GetCellInfosFromPreview(thePreview, actionTyped.bypassValidationWarnings);
+                    module.ApplySmartEdit(newValues);
+                    middlewareAPI.dispatch(PopupRedux.PopupHideScreen());
+                    return next(action);
+                }
+                /**
+                 * Use Case: Smart Edit has been applied
+                 * Action: update the grid cells
+                 */
+                case SmartEditRedux.SMART_EDIT_APPLY: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    adaptable.api.internalApi.setGridCells(actionTyped.gridCells);
+                    return returnAction;
+                }
+                /*******************
+                 * BULK UPDATE ACTIONS
+                 *******************/
+                case SystemRedux.SYSTEM_BULK_UPDATE_CHECK_CELL_SELECTION: {
+                    let module = (adaptable.modules.get(ModuleConstants.BulkUpdateModuleId));
+                    let state = middlewareAPI.getState();
+                    let returnAction = next(action);
+                    let apiReturn = module.checkCorrectCellSelection();
+                    let popup = state.Popup.ScreenPopup;
+                    // this is a horrible hack and fix for a weird issue
+                    // we really need to do smart edit and bulk update better
+                    // but this fixes it for now
+                    if (popup.ComponentName != 'LayoutPopup') {
+                        if (apiReturn.Alert) {
+                            // check if BulkUpdate is showing as popup
+                            if (popup.ComponentName == 'BulkUpdatePopup') {
+                                //We close the BulkUpdatePopup
+                                middlewareAPI.dispatch(PopupRedux.PopupHideScreen());
+                                //We show the Error Popup -- assume that will alwasy be an Error
+                                middlewareAPI.dispatch(PopupRedux.PopupShowAlert(apiReturn.Alert));
+                            }
+                        }
+                        middlewareAPI.dispatch(SystemRedux.BulkUpdateSetValidSelection(apiReturn));
+                    }
+                    return returnAction;
+                }
+                // Here we have all actions that triggers a refresh of the BulkUpdatePreview
+                case SystemRedux.SYSTEM_BULK_UPDATE_CHANGE_VALUE: {
+                    //all our logic needs to be executed AFTER the main reducers
+                    //so our state is up to date which allow us not to care about the data within each different action
+                    let returnAction = next(action);
+                    let module = (adaptable.modules.get(ModuleConstants.BulkUpdateModuleId));
+                    let state = middlewareAPI.getState();
+                    let apiReturn = module.buildPreviewValues(state.System.BulkUpdateValue);
+                    middlewareAPI.dispatch(SystemRedux.BulkUpdateSetPreview(apiReturn));
+                    return returnAction;
+                }
+                case BulkUpdateRedux.BULK_UPDATE_COMPLETE: {
+                    const actionTyped = action;
+                    let thePreview = middlewareAPI.getState().System.BulkUpdatePreviewInfo;
+                    let newValues = PreviewHelper_1.PreviewHelper.GetCellInfosFromPreview(thePreview, actionTyped.bypassValidationWarnings);
+                    adaptable.api.bulkUpdateApi.applyBulkUpdate(newValues);
+                    middlewareAPI.dispatch(PopupRedux.PopupHideScreen());
+                    return next(action);
+                }
+                case BulkUpdateRedux.BULK_UPDATE_APPLY: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    adaptable.api.internalApi.setGridCells(actionTyped.gridCells);
+                    return returnAction;
+                }
+                /*******************
+                 * PLUS MINUS ACTIONS
+                 *******************/
+                /**
+                 * Use Case: Plus Minus Rules have changed
+                 * Action: Get Plus Minus module to know if it needs to listen to keydown
+                 */
+                case PlusMinusRedux.PLUS_MINUS_RULE_ADD:
+                case PlusMinusRedux.PLUS_MINUS_RULE_EDIT:
+                case PlusMinusRedux.PLUS_MINUS_RULE_DELETE: {
+                    let returnAction = next(action);
+                    let module = adaptable.modules.get(ModuleConstants.PlusMinusModuleId);
+                    if (module) {
+                        module.checkListenToKeyDown();
+                    }
+                    return returnAction;
+                }
+                /**
+                 * Use Case: Plus Minus has been applied
+                 * Action: update the grid cells
+                 */
+                case PlusMinusRedux.PLUS_MINUS_APPLY: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    adaptable.api.internalApi.setGridCells(actionTyped.gridCells);
+                    return returnAction;
+                }
+                /*******************
+                 * SHORTCUT ACTIONS
+                 *******************/
+                /**
+                 * Use Case: Shortcuts have changed
+                 * Action: Get Shortcut module to know if it needs to listen to keydown
+                 */
+                case ShortcutRedux.SHORTCUT_ADD:
+                case ShortcutRedux.SHORTCUT_EDIT:
+                case ShortcutRedux.SHORTCUT_DELETE: {
+                    let returnAction = next(action);
+                    let module = adaptable.modules.get(ModuleConstants.ShortcutModuleId);
+                    if (module) {
+                        module.checkListenToKeyDown();
+                    }
+                    return returnAction;
+                }
+                /*******************
+                 * EXPORT ACTIONS
+                 *******************/
+                case ExportRedux.REPORT_SELECT: {
+                    const actionTyped = action;
+                    let returnAction = next(action);
+                    const selectedReport = actionTyped.SelectedReport;
+                    if (!selectedReport ||
+                        (selectedReport === GeneralConstants_1.VISUAL_DATA_REPORT &&
+                            middlewareAPI.getState().Export.CurrentDestination !== Enums_1.ExportDestination.Excel)) {
+                        middlewareAPI.dispatch(ExportRedux.DestinationSelect(''));
+                    }
+                    return returnAction;
+                }
+                case ExportRedux.EXPORT_APPLY: {
+                    let module = adaptable.modules.get(ModuleConstants.ExportModuleId);
+                    const actionTyped = action;
+                    module.export(actionTyped.Report, actionTyped.ExportDestination);
+                    middlewareAPI.dispatch(PopupRedux.PopupHideScreen());
+                    return next(action);
+                }
+                // When deleting a report check if its the currently selected one
+                // if it is then clear
+                case ExportRedux.REPORT_DELETE: {
+                    const actionTyped = action;
+                    let report = actionTyped.report;
+                    let currentReport = middlewareAPI.getState().Export.CurrentReport;
+                    if (report && report.Name == currentReport) {
+                        middlewareAPI.dispatch(ExportRedux.ReportSelect(GeneralConstants_1.EMPTY_STRING));
+                    }
+                    return next(action);
+                }
+                /*******************
+                 * TEAM SHARING ACTIONS
+                 *******************/
+                case TeamSharingRedux.TEAMSHARING_GET: {
+                    let returnAction = next(action);
+                    const { adaptableId, teamSharingOptions } = adaptable.adaptableOptions;
+                    teamSharingOptions
+                        .getSharedEntities(adaptableId)
+                        .then((sharedEntities) => {
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(sharedEntities));
+                    })
+                        .catch((error) => {
+                        LoggingHelper_1.LogAdaptableError('TeamSharing get error : ' + error.message);
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Team Sharing',
+                            message: "Couldn't get shared items: " + error.message,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                    });
+                    return returnAction;
+                }
+                // share the given AdaptableObject:
+                // - if it has dependencies, share them as well
+                // - if it's active, ensure that there is not already one present
+                // - if it's active, all the dependencies will be active as well
+                case TeamSharingRedux.TEAMSHARING_SHARE: {
+                    const actionTyped = action;
+                    let returnAction = next(action);
+                    const { Entity, Configuration, Module } = actionTyped;
+                    const { adaptableId, teamSharingOptions } = adaptable.adaptableOptions;
+                    let shareSuccessful;
+                    // load latest state from TeamSharing server
+                    teamSharingOptions
+                        .getSharedEntities(adaptableId)
+                        .then((sharedEntities) => {
+                        // check if there is not already one active SharedEntity for this object
+                        const existingActiveSharedEntity = Configuration.type === 'Active' &&
+                            adaptable.api.teamSharingApi.getTeamSharingState().ActiveSharedEntityMap[Entity.Uuid];
+                        if (existingActiveSharedEntity) {
+                            middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                                header: 'Team Sharing',
+                                message: `Couldn't share ${adaptable.api.internalApi.getModuleFriendlyName(existingActiveSharedEntity.Module)}, there is already an existing active share for it: ${existingActiveSharedEntity.Description}`,
+                                alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                            }));
+                            shareSuccessful = false;
+                            return;
+                        }
+                        // build the new shared entities incl. all their dependencies
+                        const newSharedEntityInclDependencies = adaptable.api.internalApi
+                            .getTeamSharingService()
+                            .buildSharedEntityWithDependencies(Entity, Module, Configuration);
+                        sharedEntities.push(...newSharedEntityInclDependencies);
+                        // update the local state
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingLinkItem(...newSharedEntityInclDependencies.filter((sharedEntity) => sharedEntity.Type === 'Active')));
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(sharedEntities));
+                        // update the server state
+                        shareSuccessful = true;
+                        return teamSharingOptions.setSharedEntities(adaptableId, sharedEntities);
+                    })
+                        .then(() => {
+                        if (shareSuccessful) {
+                            middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                                header: 'Team Sharing',
+                                message: `${adaptable.api.internalApi.getModuleFriendlyName(Module)} Shared Successfully`,
+                                alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Success'),
+                            }));
+                        }
+                    })
+                        .catch((error) => {
+                        LoggingHelper_1.LogAdaptableError('TeamSharing share error : ' + error.message, actionTyped.Entity);
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Team Sharing',
+                            message: "Couldn't share item: " + error.message,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                    });
+                    return returnAction;
+                }
+                // remove the given shared entity:
+                // - ensure that no other shared entities depend on it
+                case TeamSharingRedux.TEAMSHARING_REMOVE_ITEM: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    const { adaptableId, teamSharingOptions } = adaptable.adaptableOptions;
+                    // load latest state from TeamSharing server
+                    teamSharingOptions
+                        .getSharedEntities(adaptableId)
+                        .then((sharedEntities) => {
+                        // ensure that no other SharedDependencies reference the to-be-deleted entity
+                        const sharedEntityDependants = adaptable.api.internalApi
+                            .getTeamSharingService()
+                            .getSharedEntityDependants(actionTyped.Uuid, sharedEntities);
+                        if (sharedEntityDependants.length) {
+                            middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                                header: `Cannot remove the shared item as it is referenced in:`,
+                                message: sharedEntityDependants
+                                    .map((sharedEntity) => `${adaptable.api.internalApi.getModuleFriendlyName(sharedEntity.Module)} ${sharedEntity.Description}`)
+                                    .join('\n'),
+                                alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Warning'),
+                            }));
+                            return;
+                        }
+                        // remove the deleted SharedEntity from local state
+                        const newSharedEntities = sharedEntities.filter((s) => s.Uuid !== actionTyped.Uuid);
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(newSharedEntities));
+                        // update TeamSharing server
+                        return teamSharingOptions.setSharedEntities(adaptableId, newSharedEntities);
+                    })
+                        .catch((error) => {
+                        LoggingHelper_1.LogAdaptableError('TeamSharing remove error : ' + error.message);
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Team Sharing',
+                            message: "Couldn't remove item: " + error.message,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                    });
+                    return returnAction;
+                }
+                // Import 1. step
+                // prepare import of the given shared entity (the actual import is done in 'TEAMSHARING_PROCESS_IMPORT'):
+                // - all dependencies will be also included in the import bundle
+                // - if there is at least one local AdaptableObject which will be overwritten, display an confirmation pop
+                case TeamSharingRedux.TEAMSHARING_IMPORT_ITEM: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    const [importStepActions, needsOverwriteConfirmation,] = adaptable.api.internalApi
+                        .getTeamSharingService()
+                        .buildSharedEntityImportActions(actionTyped.SharedEntity);
+                    const processImportAction = TeamSharingRedux.TeamSharingProcessImport(importStepActions);
+                    if (needsOverwriteConfirmation) {
+                        let confirmation = {
+                            CancelButtonText: 'Cancel Import',
+                            Header: 'Overwrite Config',
+                            Msg: 'This import will overwrite one of your config. Do you want to continue?',
+                            ConfirmButtonText: 'Import',
+                            CancelAction: null,
+                            ConfirmAction: processImportAction,
+                            ShowInputBox: false,
+                            MessageType: 'Warning',
+                        };
+                        middlewareAPI.dispatch(PopupRedux.PopupShowConfirmation(confirmation));
+                    }
+                    else {
+                        middlewareAPI.dispatch(processImportAction);
+                    }
+                    return returnAction;
+                }
+                // Import 2. step
+                // import the actual AdaptableObjects (either create or update them)
+                case TeamSharingRedux.TEAMSHARING_PROCESS_IMPORT: {
+                    let returnAction = next(action);
+                    const actionTyped = action;
+                    const { ImportSteps } = actionTyped;
+                    const activeSharedEntities = [];
+                    // iterate backwards to import the dependencies first
+                    // it should work also the other way around, but nevertheless...
+                    for (let i = ImportSteps.length - 1; i >= 0; i--) {
+                        const { sharedEntity, importAction } = ImportSteps[i];
+                        if (importAction) {
+                            middlewareAPI.dispatch(importAction);
+                            if (sharedEntity.Type === 'Active') {
+                                activeSharedEntities.push(sharedEntity);
+                            }
+                        }
+                        else {
+                            LoggingHelper_1.LogAdaptableError('Team Sharing Import Error: Unknown item type', sharedEntity);
+                        }
+                    }
+                    if (activeSharedEntities.length) {
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingLinkItem(...activeSharedEntities));
+                    }
+                    // mark the import process as ended after (we assume that) the import is finished
+                    adaptable.api.internalApi
+                        .waitForTeamSharingImportEnd()
+                        .then(() => middlewareAPI.dispatch(TeamSharingRedux.TeamSharingCommitImport()))
+                        .catch(() => middlewareAPI.dispatch(TeamSharingRedux.TeamSharingCommitImport()));
+                    middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                        header: 'Team Sharing',
+                        message: `Item Successfully Imported`,
+                        alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Success'),
+                    }));
+                    return returnAction;
+                }
+                // update the active SharedEntity with the latest (updated) state of the local AdaptableObject
+                // - if the remote server already has a newer version of it, the update is skipped
+                case TeamSharingRedux.TEAMSHARING_UPDATE_ITEM: {
+                    const returnAction = next(action);
+                    const actionTyped = action;
+                    if (middlewareAPI.getState().TeamSharing.importProcessInProgress) {
+                        // we are in the middle of an import process, we don't have to react to these object changes
+                        return returnAction;
+                    }
+                    const { adaptableId, teamSharingOptions } = adaptable.adaptableOptions;
+                    const { ChangedAdaptableObject, UserName } = actionTyped;
+                    teamSharingOptions
+                        .getSharedEntities(adaptableId)
+                        .then((sharedEntities) => {
+                        // check if remote server has a newer revision
+                        const [localRevision, remoteRevision,] = adaptable.api.internalApi
+                            .getTeamSharingService()
+                            .getSharedEntityLocalAndRemoteRevisions(ChangedAdaptableObject.Uuid, sharedEntities);
+                        if (remoteRevision > localRevision) {
+                            // if remote has a newer version, we will NOT overwrite it
+                            return;
+                        }
+                        const [updatedSharedEntities, newActiveEntities,] = adaptable.api.internalApi
+                            .getTeamSharingService()
+                            .updateActiveSharedEntity(ChangedAdaptableObject, UserName, sharedEntities);
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingLinkItem(...newActiveEntities));
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(updatedSharedEntities));
+                        return teamSharingOptions.setSharedEntities(adaptableId, updatedSharedEntities);
+                    })
+                        .catch((error) => {
+                        LoggingHelper_1.LogAdaptableError('TeamSharing update active item error : ' + error.message);
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Team Sharing',
+                            message: "Couldn't update active item: " + error.message,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                    });
+                    return returnAction;
+                }
+                case TeamSharingRedux.TEAMSHARING_CHECK_FOR_UPDATES: {
+                    const returnAction = next(action);
+                    const { adaptableId, teamSharingOptions } = adaptable.adaptableOptions;
+                    teamSharingOptions
+                        .getSharedEntities(adaptableId)
+                        .then((sharedEntities) => {
+                        // update local state
+                        middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(sharedEntities));
+                        adaptable.api.internalApi.getTeamSharingService().showUpdateNotifications();
+                    })
+                        .catch((error) => {
+                        LoggingHelper_1.LogAdaptableError('TeamSharing update error : ' + error.message);
+                        middlewareAPI.dispatch(PopupRedux.PopupShowAlert({
+                            header: 'Team Sharing',
+                            message: "Couldn't check for updates: " + error.message,
+                            alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+                        }));
+                    });
+                    return returnAction;
+                }
+                /*******************
+                 * SYSTEM (INTERNAL) ACTIONS
+                 *******************/
+                case SystemRedux.SYSTEM_SET_NEW_COLUMN_LIST_ORDER:
+                    const actionTyped = action;
+                    adaptable.setColumnOrder(actionTyped.visibleColumnList);
+                    return next(action);
+                /*******************
+                 * GRID (INTERNAL) ACTIONS
+                 *******************/
+                case GridRedux.GRID_CREATE_CELLS_SUMMARY: {
+                    let module = (adaptable.modules.get(ModuleConstants.CellSummaryModuleId));
+                    let returnAction = next(action);
+                    let selectedCellInfo = middlewareAPI.getState().Grid.SelectedCellInfo;
+                    let apiSummaryReturn = module.createCellSummary(selectedCellInfo);
+                    middlewareAPI.dispatch(GridRedux.GridSetCellSummary(apiSummaryReturn));
+                    return returnAction;
+                }
+                case GridRedux.GRID_REFRESH_CELLS: {
+                    const actionTyped = action;
+                    let ret = next(action);
+                    adaptable.refreshCells(actionTyped.rows, actionTyped.columnIds, true);
+                    return ret;
+                }
+                case GridRedux.GRID_SET_SORT: {
+                    let ret = next(action);
+                    adaptable.api.gridApi.fireSearchChangedEvent('Sort');
+                    return ret;
+                }
+                case GridRedux.GRID_CLEAR_SORT: {
+                    let ret = next(action);
+                    adaptable.api.gridApi.fireSearchChangedEvent('Sort');
+                    return ret;
+                }
+                /*******************
+                 * POPUP (INTERNAL) ACTIONS
+                 *******************/
+                case PopupRedux.POPUP_SHOW_ALERT: {
+                    AdaptableToaster_1.showToast({
+                        api: adaptable.api,
+                        adaptableAlert: action.alert,
+                    });
+                    return next(action);
+                }
+                case PopupRedux.POPUP_CONFIRM_PROMPT: {
+                    let promptConfirmationAction = middlewareAPI.getState().Popup.PromptPopup.ConfirmAction;
+                    if (promptConfirmationAction) {
+                        let inputText = action.InputText;
+                        promptConfirmationAction.InputText = inputText;
+                        middlewareAPI.dispatch(promptConfirmationAction);
+                    }
+                    return next(action);
+                }
+                case PopupRedux.POPUP_CONFIRM_CONFIRMATION: {
+                    let confirmationAction = middlewareAPI.getState().Popup.ConfirmationPopup.ConfirmAction;
+                    if (confirmationAction) {
+                        middlewareAPI.dispatch(confirmationAction);
+                    }
+                    return next(action);
+                }
+                case PopupRedux.POPUP_CANCEL_CONFIRMATION: {
+                    let cancelAction = middlewareAPI.getState().Popup.ConfirmationPopup.CancelAction;
+                    if (cancelAction) {
+                        middlewareAPI.dispatch(cancelAction);
+                    }
+                    return next(action);
+                }
+                /*******************
+                 * MANAGING STATE ACTIONS
+                 *******************/
+                case exports.INIT_STATE: {
+                    let returnAction = next(action);
+                    // 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.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;
+                    }
+                    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();
+                    return returnAction;
+                }
+                default: {
+                    return next(action);
+                }
+            }
+        };
+    };
+};