@adaptabletools/adaptable 18.0.0-canary.4 → 18.0.0-canary.5

package/src/Strategy/AlertModule.js

@@ -13,12 +13,12 @@ import { AlertEmptyView } from '../View/Alert/AlertEmptyView';
 import { AlertStatusPanel } from '../View/Alert/AlertStatusSubPanel';
 import { ActiveAlertsPanelItemLabel } from '../View/Alert/ActiveAlertsPanelItemLabel';
 import { getObjectTagsViewItems } from './Utilities/getObjectTagsViewItems';
-import { updateSingleToMultiplePredicates } from './Utilities/updateSingleToMultiplePredicates';
-import { cloneObject } from '../Utilities/Helpers/Helper';
 import { getAlertType } from '../View/Alert/Utilities/getAlertType';
 export class AlertModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.AlertModuleId, ModuleConstants.AlertModuleFriendlyName, 'alert', 'AlertPopup', 'Get notified when things happen in Adaptable that you need to know about', api);
+    }
+    onAdaptableReady() {
         this.api.internalApi
             .getDataService()
             .on('CellDataChanged', (cellDataChangedInfo) => {
@@ -71,59 +71,6 @@ export class AlertModule extends AdaptableModuleBase {
         }
         return this.api.namedQueryApi.internalApi.getReferencedNamedQueryNames(queryExpression);
     }
-    updateOldConfig() {
-        var _a;
-        this.updateAlertSingleToMultiplePredicates();
-        // 1. Make all (new) Flashing Cells have a Predicate if none exists
-        const alertState = this.api.alertApi.getAlertState();
-        const flashingAlertDefinitions = alertState.FlashingAlertDefinitions;
-        const flashingCellDefinitions = this.api.flashingCellApi.getFlashingCellDefinitions();
-        if (ArrayExtensions.IsEmpty(flashingCellDefinitions) &&
-            ArrayExtensions.IsNotNullOrEmpty(flashingAlertDefinitions)) {
-            this.api.flashingCellApi.setFlashingCellDefinitions(flashingAlertDefinitions);
-            // TODO: state does not clear
-            this.api.flashingCellApi.internalApi.clearFlashingCellState();
-        }
-        (_a = alertState.AlertDefinitions) === null || _a === void 0 ? void 0 : _a.forEach((alertDefinition) => {
-            // if ShowPopup then change to DisplayNotificate
-            if (alertDefinition.AlertProperties &&
-                alertDefinition.AlertProperties.ShowPopup &&
-                alertDefinition.AlertProperties.ShowPopup == true &&
-                !alertDefinition.AlertProperties.DisplayNotification) {
-                alertDefinition.AlertProperties.DisplayNotification = true;
-                alertDefinition.AlertProperties.ShowPopup = undefined;
-            }
-            // if no rule but a predicate then use that
-            if (!alertDefinition.Rule) {
-                if (alertDefinition.Predicate && alertDefinition.Predicate != undefined) {
-                    const predicate = alertDefinition.Predicate;
-                    alertDefinition.Rule = {
-                        Predicate: predicate,
-                    };
-                    alertDefinition.Predicate = undefined;
-                }
-            }
-            else {
-                //migrate alert definitions with `AggregationExpression` (now `AggregatedBooleanExpression`)
-                const obsoleteAggregationExpression = alertDefinition.Rule['AggregationExpression'];
-                if (obsoleteAggregationExpression) {
-                    alertDefinition.Rule.AggregatedBooleanExpression = obsoleteAggregationExpression;
-                }
-            }
-        });
-    }
-    updateAlertSingleToMultiplePredicates() {
-        const alertDefinitions = this.api.alertApi.getAlertDefinitions({
-            includeLayoutNotAssociatedObjects: true,
-        });
-        alertDefinitions.forEach((alertDefinition) => {
-            if (alertDefinition.Rule && 'Predicate' in alertDefinition.Rule) {
-                const preparedAlertDefinition = cloneObject(alertDefinition);
-                updateSingleToMultiplePredicates(preparedAlertDefinition.Rule);
-                this.api.alertApi.editAlertDefinition(preparedAlertDefinition);
-            }
-        });
-    }
     addContextMenuItems(menuContext) {
         const items = [];
         if (!menuContext.isRowGroupColumn && this.isModuleAvailable()) {

package/src/Strategy/CalculatedColumnModule.d.ts

@@ -8,12 +8,11 @@ import { CalculatedColumn } from '../PredefinedConfig/CalculatedColumnState';
 import { AdaptableObjectItemView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
-import { AdaptableStateReloadedInfo } from '../Api/Events/AdaptableStateReloaded';
 export declare class CalculatedColumnModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    handleConfigReloaded(adaptableStateReloadedInfo: AdaptableStateReloadedInfo): void;
+    onAdaptableReady(): void;
+    onAdaptableStateReloaded(): void;
     getModuleAdaptableObjects(): AdaptableObject[];
-    updateOldConfig(): void;
     getExplicitlyReferencedColumnIds(calculatedColumn: CalculatedColumn): string[];
     getReferencedNamedQueryNames(calculatedColumn: CalculatedColumn): string[];
     private isCalculatedColumn;

package/src/Strategy/CalculatedColumnModule.js

@@ -11,35 +11,15 @@ export class CalculatedColumnModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.CalculatedColumnModuleId, ModuleConstants.CalculatedColumnFriendlyName, 'chart-and-grid', 'CalculatedColumnPopup', 'Create bespoke columns whose cell value is derived dynamically from an Expression', api);
     }
-    handleConfigReloaded(adaptableStateReloadedInfo) {
-        // re-dispatch the CalculatedColumnReady action to recreate all the aggregated scalar columns
-        this.api.internalApi.dispatchReduxAction(CalculatedColumnRedux.CalculatedColumnReady(this.api.calculatedColumnApi.getCalculatedColumnState()));
+    onAdaptableReady() {
+        this.api.calculatedColumnApi.refreshAggregatedCalculatedColumns();
+    }
+    onAdaptableStateReloaded() {
+        this.api.calculatedColumnApi.refreshAggregatedCalculatedColumns();
     }
     getModuleAdaptableObjects() {
         return this.api.calculatedColumnApi.getCalculatedColumns();
     }
-    updateOldConfig() {
-        const calcColumns = this.api.calculatedColumnApi.getCalculatedColumns();
-        let oldCalculatedColumns = [];
-        calcColumns.forEach((cc) => {
-            if (cc.ColumnExpression && !cc.Query) {
-                cc.Query = {
-                    ScalarExpression: cc.ColumnExpression,
-                };
-                cc.ColumnExpression = undefined;
-                oldCalculatedColumns.push(cc);
-                this.api.logWarn(`Updating incorrect Predefined Config for Calculated Column: ${cc.ColumnId}`);
-            }
-            if (!cc.CalculatedColumnSettings) {
-                cc.CalculatedColumnSettings = {
-                    DataType: 'Number',
-                };
-                oldCalculatedColumns.push(cc);
-                this.api.logWarn(`Updating incorrect Predefined Config for Calculated Column: ${cc.ColumnId}`);
-            }
-        });
-        oldCalculatedColumns.forEach((oldCalcCol) => this.api.calculatedColumnApi.editCalculatedColumn(oldCalcCol));
-    }
     getExplicitlyReferencedColumnIds(calculatedColumn) {
         var _a;
         return ((_a = this.api.expressionApi.getColumnsFromExpression(this.api.expressionApi.getAdaptableQueryExpression(calculatedColumn.Query))) !== null && _a !== void 0 ? _a : []);

package/src/Strategy/ChartingModule.d.ts

@@ -5,7 +5,6 @@ import { ChartDefinition } from '../types';
 import { ExternalChartDefinition } from '../PredefinedConfig/ChartingState';
 export declare class ChartingModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    updateOldConfig(): void;
     isModuleAvailable(): boolean;
     getModuleAdaptableObjects(): (ChartDefinition | ExternalChartDefinition)[];
     toViewAll(): AdaptableObjectView[];

package/src/Strategy/ChartingModule.js

@@ -11,27 +11,6 @@ export class ChartingModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.ChartingModuleId, ModuleConstants.ChartingFriendlyName, 'chart', 'ChartPopup', 'Create AG Grid Charts in order to see Adaptable Data visually', api);
     }
-    updateOldConfig() {
-        const allChartDefinitions = this.api.chartingApi.getChartDefinitions();
-        const chartDefinitionsToUpdate = allChartDefinitions
-            .filter((chartDefinition) => 'model' in chartDefinition || !('Name' in chartDefinition))
-            .map((charDefinition) => {
-            const newChartDefinition = Object.assign({}, charDefinition);
-            if ('model' in newChartDefinition) {
-                newChartDefinition.Model = charDefinition.model;
-                delete newChartDefinition.model;
-            }
-            if (!('Name' in newChartDefinition)) {
-                // default to chartId
-                // @ts-ignore possible because First iteration had no 'Name' and model was under 'model' key (lowercase)
-                newChartDefinition.Name = newChartDefinition.Model.chartId;
-            }
-            return newChartDefinition;
-        });
-        if (chartDefinitionsToUpdate.length > 0) {
-            chartDefinitionsToUpdate.forEach((chartDefinition) => this.api.chartingApi.editChartDefinition(chartDefinition));
-        }
-    }
     isModuleAvailable() {
         const agChartsAvailable = this.api.chartingApi.isChartingEnabled() && super.isModuleAvailable();
         const externalChartsAvailable = Helper.objectHasKeys(this.api.optionsApi.getChartingOptions().externalChartingOptions);

package/src/Strategy/ColumnFilterModule.d.ts

@@ -12,8 +12,7 @@ export declare class ColumnFilterModule extends AdaptableModuleBase implements I
     getModuleAdaptableObjects(): AdaptableObject[];
     getExplicitlyReferencedColumnIds(columnFilter: ColumnFilter): string[];
     hasNamedQueryReferences(): boolean;
-    updateOldConfig(): void;
-    handleAdaptableReady(): void;
+    onAdaptableReady(): void;
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     private getExistingColumnFilter;

package/src/Strategy/ColumnFilterModule.js

@@ -28,70 +28,7 @@ export class ColumnFilterModule extends AdaptableModuleBase {
     hasNamedQueryReferences() {
         return false;
     }
-    updateOldConfig() {
-        // Note: have updated Dashboard and Status bar but NOT Tool Panels
-        // Update Module Buttons
-        let updateModuleButtons = false;
-        let moduleButtons = this.api.dashboardApi.getModuleButtons();
-        if (!moduleButtons.includes('ColumnFilter')) {
-            moduleButtons = moduleButtons.map((moduleButton) => {
-                if (moduleButton == 'Filter') {
-                    updateModuleButtons = true;
-                    return 'ColumnFilter';
-                }
-                return moduleButton;
-            });
-        }
-        if (updateModuleButtons) {
-            this.api.dashboardApi.setModuleButtons(moduleButtons);
-        }
-        // Update Toolbars
-        let updateTabs = false;
-        const tabs = this.api.dashboardApi.getTabs().map((tab) => {
-            if (tab.Toolbars.includes('Filter') && !tab.Toolbars.includes('ColumnFilter')) {
-                updateTabs = true;
-                return Object.assign(Object.assign({}, tab), { 
-                    // replace with 'GridFilter'
-                    Toolbars: tab.Toolbars.map((t) => (t == 'Filter' ? 'ColumnFilter' : t)) });
-            }
-            return tab;
-        });
-        if (updateTabs) {
-            this.api.dashboardApi.setTabs(tabs);
-        }
-        // - move pinned toolbars
-        let updatePinnedToolbars = false;
-        let pinnedToolbars = this.api.dashboardApi.getPinnedToolbars();
-        if (pinnedToolbars && !(pinnedToolbars === null || pinnedToolbars === void 0 ? void 0 : pinnedToolbars.includes('ColumnFilter'))) {
-            pinnedToolbars = pinnedToolbars.map((pinnedToolbar) => {
-                if (pinnedToolbar == 'Filter') {
-                    updatePinnedToolbars = true;
-                    return 'ColumnFilter';
-                }
-                return pinnedToolbar;
-            });
-        }
-        if (updatePinnedToolbars) {
-            this.api.dashboardApi.setPinnedToolbars(pinnedToolbars);
-        }
-        // Update Status Bar
-        let updateStatusBars = false;
-        const statusBars = this.api.statusBarApi
-            .getAdaptableStatusBars()
-            .map((panel) => {
-            return Object.assign(Object.assign({}, panel), { StatusBarPanels: panel.StatusBarPanels.map((panel) => {
-                    if (panel === 'Filter') {
-                        updateStatusBars = true;
-                        return 'ColumnFilter';
-                    }
-                    return panel;
-                }) });
-        });
-        if (updateStatusBars) {
-            this.api.statusBarApi.setStatusBarPanels(statusBars);
-        }
-    }
-    handleAdaptableReady() {
+    onAdaptableReady() {
         if (this.api.optionsApi.getColumnFilterOptions().quickFilterOptions.showQuickFilter == false) {
             this.api.columnFilterApi.hideQuickFilterBar();
         }

package/src/Strategy/CommentsModule.d.ts

@@ -9,6 +9,7 @@ import { IModule } from './Interface/IModule';
 export declare class CommentsModule extends AdaptableModuleBase implements IModule {
     private adaptable;
     constructor(api: AdaptableApi);
+    onAdaptableReady(): void;
     isModuleAvailable(): boolean;
     private loadComments;
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;

package/src/Strategy/CommentsModule.js

@@ -9,7 +9,8 @@ export class CommentsModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.CommentsModuleId, ModuleConstants.CommentsFriendlyName, 'comments', 'CommentsPopup', 'comments', api);
         this.adaptable = api.internalApi.getAdaptableInstance();
-        this.adaptable.api.eventApi.on('AdaptableReady', () => this.handleAdaptableReady());
+    }
+    onAdaptableReady() {
         this.loadComments();
     }
     isModuleAvailable() {

package/src/Strategy/CustomSortModule.js

@@ -25,7 +25,7 @@ export class CustomSortModule extends AdaptableModuleBase {
                 .find((x) => x.ColumnId == column.columnId);
             let label = customSort ? 'Edit ' : 'Create ';
             // dont show a menu item if there is a custom sort that uses a comparer function
-            const columnSortComparer = this.api.customSortApi.internalApi.getCustomSortComparer(column);
+            const columnSortComparer = this.api.customSortApi.internalApi.getCustomSortComparer(column.columnId);
             if (columnSortComparer) {
                 return undefined;
             }

package/src/Strategy/DashboardModule.d.ts

@@ -4,8 +4,7 @@ import { IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 export declare class DashboardModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    updateOldConfig(): void;
-    handleAdaptableReady(): void;
+    onAdaptableReady(): void;
     addColumnMenuItems(): AdaptableMenuItem[] | undefined;
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     private buildMenuItems;

package/src/Strategy/DashboardModule.js

@@ -5,14 +5,7 @@ export class DashboardModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.DashboardModuleId, ModuleConstants.DashboardFriendlyName, 'dashboard', 'DashboardPopup', 'The Dashboard - usually placed above the Grid - is designed to provide quick access to commonly required AdapTable functionalty', api);
     }
-    updateOldConfig() {
-        let dashboardState = this.api.dashboardApi.getDashboardState();
-        if (dashboardState.VisibleButtons) {
-            this.api.logWarn(`Updating Obsolete VisibleButtons Config for DashboardState: [${dashboardState.VisibleButtons}]`);
-            this.api.dashboardApi.setModuleButtons(dashboardState.VisibleButtons);
-        }
-    }
-    handleAdaptableReady() {
+    onAdaptableReady() {
         // we used to create a default tab here but we no longer do // this.api.internalApi.setDefaultDashboardTab();
         // this handler reacts to the 'AdaptableReady' event,
         // but so do all the other possible handlers of the 'DashboardChanged' event

package/src/Strategy/DataChangeHistoryModule.d.ts

@@ -3,6 +3,7 @@ import { AdaptableModuleView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 export declare class DataChangeHistoryModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
+    onAdaptableReady(): void;
     isModuleAvailable(): boolean;
     getPopupMaxWidth(): number;
     hasNamedQueryReferences(): boolean;

package/src/Strategy/DataChangeHistoryModule.js

@@ -6,6 +6,8 @@ import { ModuleNames } from '@ag-grid-community/core';
 export class DataChangeHistoryModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.DataChangeHistoryModuleId, ModuleConstants.DataChangeHistoryFriendlyName, 'target', 'DataChangeHistoryPopup', 'Provides an overview of all previous changes, giving the possibility to undo specific changes', api);
+    }
+    onAdaptableReady() {
         this.api.internalApi
             .getDataService()
             .on('CellDataChanged', (cellDataChangedInfo) => {
@@ -20,7 +22,7 @@ export class DataChangeHistoryModule extends AdaptableModuleBase {
         const isAdaptableModuleAvailable = super.isModuleAvailable();
         const isAgGridModuleAvailable = this.api.internalApi
             .getAdaptableInstance()
-            .isAgGridModulePresent(ModuleNames.ClientSideRowModelModule);
+            .agGridAdapter.isModulePresent(ModuleNames.ClientSideRowModelModule);
         if (isAdaptableModuleAvailable && !isAgGridModuleAvailable) {
             this.api.logWarn(`Data Change History is NOT available due to missing required AG Grid module: ${ModuleNames.ClientSideRowModelModule}`);
         }

package/src/Strategy/DataSetModule.d.ts

@@ -5,7 +5,7 @@ import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 import { DataSet } from '../AdaptableOptions/DataSetOptions';
 export declare class DataSetModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    handleAdaptableReady(): void;
+    onAdaptableReady(): void;
     getModuleAdaptableObjects(): AdaptableObject[];
     hasNamedQueryReferences(): boolean;
     toView(dataSet: DataSet): AdaptableObjectView;

package/src/Strategy/DataSetModule.js

@@ -8,7 +8,7 @@ export class DataSetModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.DataSetModuleId, ModuleConstants.DataSetFriendlyName, 'data-set', 'DataSetPopup', 'Update the entire data source in AdapTable using pre-populated data sets', api);
     }
-    handleAdaptableReady() {
+    onAdaptableReady() {
         this.api.dataSetApi.getDataSets().forEach((ds) => {
             if (!ds.Uuid) {
                 ds.Uuid = createUuid();

package/src/Strategy/FlashingCellModule.d.ts

@@ -9,8 +9,7 @@ import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 import { FlashingCellDefinition } from '../PredefinedConfig/FlashingCellState';
 export declare class FlashingCellModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    updateOldConfig(): void;
-    private updateFlashingCellSingleToMultiplePredicates;
+    onAdaptableReady(): void;
     getModuleAdaptableObjects(config?: {
         includeLayoutNotAssociatedObjects?: boolean;
     }): AdaptableObject[];

package/src/Strategy/FlashingCellModule.js

@@ -11,11 +11,11 @@ import { FlashingCellWizard } from '../View/FlashingCell/Wizard/FlashingCellWiza
 import { getObjectTagsViewItems } from './Utilities/getObjectTagsViewItems';
 import { getFlashingTargetViewItems } from './Utilities/FlashingCell/getFlashingTargetViewItems';
 import { getFlashingCellStyleViewItems } from './Utilities/FlashingCell/getFlashingCellStyleViewItems';
-import { cloneObject } from '../Utilities/Helpers/Helper';
-import { updateSingleToMultiplePredicates } from './Utilities/updateSingleToMultiplePredicates';
 export class FlashingCellModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.FlashingCellModuleId, ModuleConstants.FlashingCellFriendlyName, 'lightning', 'FlashingAlert', 'Flash cells when they change', api);
+    }
+    onAdaptableReady() {
         this.api.internalApi
             .getDataService()
             .on('CellDataChanged', (cellDataChangedInfo) => {
@@ -38,19 +38,6 @@ export class FlashingCellModule extends AdaptableModuleBase {
             this.handleCellDataChanged(cellDataChangedInfo);
         });
     }
-    updateOldConfig() {
-        this.updateFlashingCellSingleToMultiplePredicates();
-    }
-    updateFlashingCellSingleToMultiplePredicates() {
-        const flashingCells = this.api.flashingCellApi.getFlashingCellDefinitions();
-        flashingCells.forEach((flashingCell) => {
-            if (flashingCell.Rule && 'Predicate' in flashingCell.Rule) {
-                const preparedFlashingCell = cloneObject(flashingCell);
-                updateSingleToMultiplePredicates(preparedFlashingCell.Rule);
-                this.api.flashingCellApi.editFlashingCellDefinition(preparedFlashingCell);
-            }
-        });
-    }
     getModuleAdaptableObjects(config) {
         return this.api.flashingCellApi.getFlashingCellDefinitions(config);
     }

package/src/Strategy/FormatColumnModule.d.ts

@@ -13,8 +13,6 @@ export declare class FormatColumnModule extends AdaptableModuleBase implements I
     }): AdaptableObject[];
     getExplicitlyReferencedColumnIds(formatColumn: FormatColumn): string[];
     getReferencedNamedQueryNames(formatColumn: FormatColumn): string[];
-    updateOldConfig(): void;
-    private updateFormatColumnSingleToMultiplePredicates;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<FormatColumn>;
     toView(formatColumn: FormatColumn): AdaptableObjectView;

package/src/Strategy/FormatColumnModule.js

@@ -10,8 +10,6 @@ import { getFormatColumnStyleViewItems } from './Utilities/FormatColumn/getForma
 import { getObjectTagsViewItems } from './Utilities/getObjectTagsViewItems';
 import { getRuleViewItems } from './Utilities/getRuleViewItems';
 import { MoveFormatColumn } from '../View/FormatColumn/MoveFormatColumn';
-import { cloneObject } from '../Utilities/Helpers/Helper';
-import { updateSingleToMultiplePredicates } from './Utilities/updateSingleToMultiplePredicates';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 export class FormatColumnModule extends AdaptableModuleBase {
     constructor(api) {
@@ -39,51 +37,6 @@ export class FormatColumnModule extends AdaptableModuleBase {
         }
         return this.api.namedQueryApi.internalApi.getReferencedNamedQueryNames(queryExpression);
     }
-    updateOldConfig() {
-        this.updateFormatColumnSingleToMultiplePredicates();
-        // update ConditionalStyle StatusBarPanel
-        const oldStatusBars = this.api.internalApi.getState().StatusBar.StatusBars;
-        let replaceConditionalStyleStatusBar = false;
-        const newStatusBars = oldStatusBars.map((statusBar) => (Object.assign(Object.assign({}, statusBar), { StatusBarPanels: [
-                ...new Set(statusBar.StatusBarPanels.map((statusBarPanel) => {
-                    if (statusBarPanel === 'ConditionalStyle') {
-                        replaceConditionalStyleStatusBar = true;
-                        return 'FormatColumn';
-                    }
-                    return statusBarPanel;
-                })),
-            ] })));
-        if (replaceConditionalStyleStatusBar) {
-            this.api.statusBarApi.setStatusBarPanels(newStatusBars);
-        }
-        // update ConditionalStyle dashboard buttons
-        const dashboardModuleButtons = this.api.internalApi.getState().Dashboard.ModuleButtons;
-        if (dashboardModuleButtons.includes('ConditionalStyle')) {
-            dashboardModuleButtons[dashboardModuleButtons.indexOf('ConditionalStyle')] = 'FormatColumn';
-            const test2 = dashboardModuleButtons;
-            this.api.dashboardApi.setModuleButtons([
-                ...new Set(dashboardModuleButtons),
-            ]);
-        }
-        // update ConditionalStyle toolPanel buttons
-        const toolPanelModuleButtons = this.api.internalApi.getState().ToolPanel.ModuleButtons;
-        if (toolPanelModuleButtons.includes('ConditionalStyle')) {
-            toolPanelModuleButtons[toolPanelModuleButtons.indexOf('ConditionalStyle')] = 'FormatColumn';
-            this.api.toolPanelApi.setModuleButtons([
-                ...new Set(dashboardModuleButtons),
-            ]);
-        }
-    }
-    updateFormatColumnSingleToMultiplePredicates() {
-        const formatColumns = this.api.formatColumnApi.getFormatColumns();
-        formatColumns.forEach((formatColumn) => {
-            if (formatColumn.Rule && 'Predicate' in formatColumn.Rule) {
-                const preparedFormatColumn = cloneObject(formatColumn);
-                updateSingleToMultiplePredicates(preparedFormatColumn.Rule);
-                this.api.formatColumnApi.editFormatColumn(preparedFormatColumn);
-            }
-        });
-    }
     addColumnMenuItems(column) {
         let returnColumnMenuItems = [];
         if (column && this.isModuleEditable() && !column.isSparkline) {

package/src/Strategy/FreeTextColumnModule.d.ts

@@ -12,7 +12,6 @@ export declare class FreeTextColumnModule extends AdaptableModuleBase implements
     isModuleAvailable(): boolean;
     getModuleAdaptableObjects(): FreeTextColumn[];
     hasNamedQueryReferences(): boolean;
-    updateOldConfig(): void;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<FreeTextColumn>;
     toView(freeTextColumn: FreeTextColumn): AdaptableObjectView;

package/src/Strategy/FreeTextColumnModule.js

@@ -17,36 +17,6 @@ export class FreeTextColumnModule extends AdaptableModuleBase {
     hasNamedQueryReferences() {
         return false;
     }
-    updateOldConfig() {
-        // make sure all default to type string
-        const allFreeTextColumns = this.getModuleAdaptableObjects();
-        for (const freeTextColumn of allFreeTextColumns) {
-            const unTypedCol = freeTextColumn;
-            if (unTypedCol.DataType) {
-                const dataType = unTypedCol.DataType;
-                delete unTypedCol['DataType'];
-                if (!freeTextColumn.FreeTextColumnSettings) {
-                    freeTextColumn.FreeTextColumnSettings = {
-                        DataType: dataType,
-                    };
-                }
-                else {
-                    freeTextColumn.FreeTextColumnSettings.DataType = dataType;
-                }
-                this.api.freeTextColumnApi.editFreeTextColumn(freeTextColumn);
-            }
-            if (!freeTextColumn.FreeTextColumnSettings) {
-                freeTextColumn.FreeTextColumnSettings = {
-                    DataType: 'String',
-                };
-                this.api.freeTextColumnApi.editFreeTextColumn(freeTextColumn);
-            }
-            if (!freeTextColumn.FreeTextColumnSettings.DataType) {
-                freeTextColumn.FreeTextColumnSettings.DataType = 'String';
-                this.api.freeTextColumnApi.editFreeTextColumn(freeTextColumn);
-            }
-        }
-    }
     addColumnMenuItems(column) {
         if (column && this.isModuleEditable()) {
             if (this.api.freeTextColumnApi

package/src/Strategy/GridFilterModule.d.ts

@@ -3,6 +3,5 @@ import { AdaptableModuleView, IModule } from './Interface/IModule';
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 export declare class GridFilterModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    updateOldConfig(): void;
     getViewProperties(): AdaptableModuleView;
 }

package/src/Strategy/GridFilterModule.js

@@ -2,47 +2,10 @@ import { AdaptableModuleBase } from './AdaptableModuleBase';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
 import { EditGridFilterButton } from '../View/NamedQuery/EditCurrentQueryButton';
 import { GridFilterStatusbar } from '../View/GridFilter/GridFilterStatusbar';
-import StringExtensions from '../Utilities/Extensions/StringExtensions';
 export class GridFilterModule extends AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.GridFilterModuleId, ModuleConstants.GridFilterFriendlyName, 'filter-list', 'GridFilterPopup', 'Controls the Grid Filter funtionality', api);
     }
-    updateOldConfig() {
-        var _a, _b;
-        const oldQueryState = this.api.internalApi.getAdaptableState().Query;
-        // - move query to current layout
-        const expression = oldQueryState.CurrentQuery;
-        if (expression &&
-            StringExtensions.IsNullOrEmpty(this.api.gridFilterApi.getCurrentGridFilterExpression())) {
-            this.api.gridFilterApi.setGridFilterExpression(expression);
-        }
-        // - move dashboard/toolbar
-        let updateTabs = false;
-        const tabs = this.api.dashboardApi.getTabs().map((tab) => {
-            if (tab.Toolbars.includes('Query')) {
-                updateTabs = true;
-                return Object.assign(Object.assign({}, tab), { 
-                    // replace with 'GridFilter'
-                    Toolbars: tab.Toolbars.map((t) => (t == 'Query' ? 'GridFilter' : t)) });
-            }
-            return tab;
-        });
-        if (updateTabs) {
-            this.api.dashboardApi.setTabs(tabs);
-        }
-        // - move pinned toolbars
-        let updatePinnedToolbars = false;
-        const pinnedToolbars = (_b = (_a = this.api.dashboardApi.getPinnedToolbars()) === null || _a === void 0 ? void 0 : _a.map) === null || _b === void 0 ? void 0 : _b.call(_a, (pinnedToolbar) => {
-            if (pinnedToolbar == 'Query') {
-                updatePinnedToolbars = true;
-                return 'GridFilter';
-            }
-            return pinnedToolbar;
-        });
-        if (updatePinnedToolbars) {
-            this.api.dashboardApi.setPinnedToolbars(pinnedToolbars);
-        }
-    }
     getViewProperties() {
         return {
             getStatusBarPanelProps: () => {

package/src/Strategy/Interface/IModule.d.ts

@@ -156,7 +156,6 @@ export interface IModule {
     getModuleFreeTextColumnReferences(): FreeTextColumn[];
     getPopupMaxWidth(): number | undefined;
     canBeAssociatedWithLayouts(): boolean;
-    updateOldConfig(): void;
     /**
      * The following view options are used to render adaptable objects and
      * module general views.

package/src/Strategy/LayoutModule.d.ts

@@ -10,13 +10,11 @@ import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 export declare class LayoutModule extends AdaptableModuleBase implements IModule {
     protected LayoutState: LayoutState;
     constructor(api: AdaptableApi);
-    updateOldConfig(): void;
-    private clearUnsuportedFeaturesFromLayout;
+    onAdaptableReady(): void;
     getModuleAdaptableObjects(): AdaptableObject[];
     getExplicitlyReferencedColumnIds(layout: Layout): string[];
     getTeamSharingReferences(adaptableObject: AdaptableObject): TeamSharingReferences;
     hasNamedQueryReferences(): boolean;
-    handleAdaptableReady(): void;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     private createViewPivotItemsMenuItem;