@adaptabletools/adaptable 10.0.4-canary.2 → 11.0.0-canary.0

package/src/Strategy/AlertModule.js

@@ -8,10 +8,13 @@ const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/Mod
 const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const AdaptableQuery_1 = require("../PredefinedConfig/Common/AdaptableQuery");
-const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
-const ANY_PREDICATE = {
-    PredicateId: 'Any',
-};
+const ObjectFactory_1 = tslib_1.__importDefault(require("../Utilities/ObjectFactory"));
+const AlertWizard_1 = require("../View/Alert/Wizard/AlertWizard");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const getRuleViewItems_1 = require("./Utilities/getRuleViewItems");
+const getAlertPreviewViewItems_1 = require("./Utilities/getAlertPreviewViewItems");
+const getAlertBehaviourViewItems_1 = require("./Utilities/getAlertBehaviourViewItems");
+const AlertEmptyView_1 = require("../View/Alert/AlertEmptyView");
 class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.AlertModuleId, 'Alert', 'alert', 'AlertPopup', 'Get notified when things happen in Adaptable that you need to know about', api);
@@ -38,10 +41,7 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             .onReactiveAlertTriggered((reactiveAlertInfo) => this.handleReactiveAlertTriggered(reactiveAlertInfo));
     }
     getModuleAdaptableObjects() {
-        return [
-            ...this.api.alertApi.getAlertDefinitions(),
-            ...this.api.alertApi.getFlashingAlertDefinitions(),
-        ];
+        return this.api.alertApi.getAlertDefinitions();
     }
     getExplicitlyReferencedColumnIds(alertDefinition) {
         const queryExpression = AdaptableQuery_1.getAdaptableQueryExpression(alertDefinition.Rule);
@@ -63,64 +63,14 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         return this.api.queryApi.getReferencedNamedQueryNames(queryExpression);
     }
     updateOldConfig() {
-        var _a, _b;
-        /*
-        Need to do 4 things here:
-         1. Make all (new) Flashing Alerts have a Predicate if none exists
-         2. Convert old Alert Rules to use new syntax
-         3. Convert old Flashing Cells into Flashing Alerts
-         4. Convert old Updated Rows into Flashing Alerts
-        */
-        let oldAlertDefinitions = [];
         // 1. Make all (new) Flashing Alerts have a Predicate if none exists
-        (_a = this.api.alertApi
-            .getAlertState()
-            .FlashingAlertDefinitions) === null || _a === void 0 ? void 0 : _a.forEach((flashingAlertDefinition) => {
-            var _a, _b, _c;
-            if (!((_a = flashingAlertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression) &&
-                !((_b = flashingAlertDefinition.Rule) === null || _b === void 0 ? void 0 : _b.ObservableExpression) &&
-                !((_c = flashingAlertDefinition.Rule) === null || _c === void 0 ? void 0 : _c.Predicate)) {
-                flashingAlertDefinition.Rule = {
-                    Predicate: ANY_PREDICATE,
-                };
-                oldAlertDefinitions.push(flashingAlertDefinition);
-            }
-        });
-        //  2. Convert old Alert Rules to use new syntax
-        (_b = this.api.alertApi.getAlertState().AlertDefinitions) === null || _b === void 0 ? void 0 : _b.forEach((alertDefinition) => {
-            if (alertDefinition.Predicate) {
-                alertDefinition.Rule = {
-                    Predicate: alertDefinition.Predicate,
-                };
-                LoggingHelper_1.LogAdaptableWarning(`Updating incorrect Predefined Config for Alert Definition: ${alertDefinition.predicate}`);
-                alertDefinition.Predicate = undefined;
-                oldAlertDefinitions.push(alertDefinition);
-            }
-        });
-    }
-    addColumnMenuItems(column) {
-        if (column && this.isModuleEditable()) {
-            if (!this.api.columnApi.isCalculatedColumn(column.columnId)) {
-                const flashingAlertDefinitions = this.api.alertApi.getFlashingAlertDefinitions();
-                const flashingAlertForCurrentColumn = flashingAlertDefinitions.find((flashingAlertDefinition) => {
-                    return this.api.scopeApi.isColumnInScope(column, flashingAlertDefinition.Scope);
-                });
-                if (flashingAlertForCurrentColumn) {
-                    return [
-                        this.createColumnMenuItemReduxAction('Remove Flashing Alert', this.moduleInfo.Glyph, AlertRedux.FlashingAlertDefinitionDelete(flashingAlertForCurrentColumn)),
-                    ];
-                }
-                return [
-                    this.createColumnMenuItemReduxAction('Add Flashing Alert', this.moduleInfo.Glyph, AlertRedux.FlashingAlertDefinitionAdd({
-                        Scope: {
-                            ColumnIds: [column.columnId],
-                        },
-                        Rule: {
-                            Predicate: { PredicateId: 'Any' },
-                        },
-                    })),
-                ];
-            }
+        const flashingAlertDefinitions = this.api.alertApi.getAlertState().FlashingAlertDefinitions;
+        const flashingCellDefinitions = this.api.flashingCellApi.getFlashingCellDefinitions();
+        if (ArrayExtensions_1.ArrayExtensions.IsEmpty(flashingCellDefinitions) &&
+            ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(flashingAlertDefinitions)) {
+            this.api.flashingCellApi.setFlashingCellDefinitions(flashingAlertDefinitions);
+            // TODO: state does not clear
+            this.api.internalApi.clearFlashingCellState();
         }
     }
     addContextMenuItems(menuContext) {
@@ -136,14 +86,6 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                         items.push(this.createColumnMenuItemReduxAction('Clear Alert', this.moduleInfo.Glyph, SystemRedux.SystemAlertDelete(relevantAlert)));
                     }
                 }
-                const flashingAlertForRow = this.api.internalApi.getAdaptableFlashingAlertFor(menuContext.primaryKeyValue);
-                const flashingAlertForCell = this.api.internalApi.getAdaptableFlashingAlertFor(menuContext.primaryKeyValue, menuContext.adaptableColumn.columnId);
-                if (flashingAlertForRow && flashingAlertForRow.flashTarget === 'row') {
-                    items.push(this.createColumnMenuItemReduxAction('Clear Flashing Alert for Row', this.moduleInfo.Glyph, SystemRedux.SystemFlashingAlertDelete(flashingAlertForRow)));
-                }
-                else if (flashingAlertForCell && flashingAlertForCell.flashTarget === 'cell') {
-                    items.push(this.createColumnMenuItemReduxAction('Clear Flashing Alert for Cell', this.moduleInfo.Glyph, SystemRedux.SystemFlashingAlertDelete(flashingAlertForCell)));
-                }
             }
         }
         return items;
@@ -153,10 +95,6 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(alertDefinitions)) {
             this.showAlertForDefinitions(dataChangedInfo, alertDefinitions);
         }
-        const flashingAlertDefinitions = this.getFlashingAlertDefinitionsForDataChange(dataChangedInfo);
-        if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(flashingAlertDefinitions)) {
-            this.showFlashingAlertsForDefinitions(dataChangedInfo, flashingAlertDefinitions);
-        }
     }
     handleReactiveAlertTriggered(reactiveAlertInfo) {
         var _a;
@@ -171,60 +109,16 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 reactiveAlertInfo.alertDefinition,
             ]);
         }
-        else {
-            this.showFlashingAlertsForDefinitions(reactiveAlertInfo.dataChangeLogEntry, [
-                reactiveAlertInfo.alertDefinition,
-            ]);
-        }
     }
     showAlertForDefinitions(dataChangedInfo, alertDefinitions = []) {
         alertDefinitions.forEach((alertDefinition) => {
-            // might be better to do a single alert with all the messages?
-            this.api.alertApi.showAlert(dataChangedInfo.column.friendlyName, this.api.alertApi.getAlertDescription(alertDefinition, dataChangedInfo), alertDefinition, dataChangedInfo);
-        });
-    }
-    showFlashingAlertsForDefinitions(dataChangedInfo, flashingAlertDefinitions = []) {
-        const allColumnIds = this.api.columnApi.getColumns().map((c) => c.columnId);
-        const columnDataType = dataChangedInfo.column.dataType;
-        const numeric = columnDataType === 'Number';
-        const isComparableType = numeric || columnDataType === 'Date';
-        let up = false;
-        let down = false;
-        let direction = 'neutral';
-        if (isComparableType) {
-            const newValue = numeric ? Number(dataChangedInfo.newValue) : dataChangedInfo.newValue;
-            const oldValue = numeric ? Number(dataChangedInfo.oldValue) : dataChangedInfo.oldValue;
-            up = newValue > oldValue;
-            down = newValue < oldValue;
-            direction = up ? 'up' : down ? 'down' : 'neutral';
-        }
-        flashingAlertDefinitions.forEach((flashingAlertDefinition) => {
-            const flashTarget = this.api.alertApi.getFlashingAlertFlashTarget(flashingAlertDefinition);
-            const flashColumnIds = { [dataChangedInfo.column.columnId]: true };
-            if (flashTarget === 'row') {
-                allColumnIds.forEach((colId) => {
-                    flashColumnIds[colId] = true;
-                });
-            }
-            const rowPrimaryKey = dataChangedInfo.primaryKeyValue;
-            this.api.alertApi.showFlashingAlert({
-                rowPrimaryKey,
-                flashingAlertDefinition,
-                dataChangedInfo,
-                direction,
-                flashTarget,
-                flashColumnIds,
-            });
+            const alert = ObjectFactory_1.default.CreateAlert(dataChangedInfo.column.friendlyName, this.api.alertApi.getAlertDescription(alertDefinition, dataChangedInfo), alertDefinition, dataChangedInfo);
+            this.api.alertApi.displayAlert(alert);
         });
     }
     getAlertDefinitionsForDataChange(dataChangedEvent) {
         return this.getBaseAlertDefinitionsForDataChange(dataChangedEvent, this.api.alertApi.getActiveNonReactiveAlertDefinitions());
     }
-    getFlashingAlertDefinitionsForDataChange(dataChangedEvent) {
-        return this.getBaseAlertDefinitionsForDataChange(dataChangedEvent, 
-        // reactive flashing alert definitions are excluded as they are handled separately (asynchronously)
-        this.api.alertApi.getActiveNonReactiveFlashingAlertDefinitions(), true);
-    }
     getBaseAlertDefinitionsForDataChange(dataChangedEvent, definitions, defaultNoPredicateReturn = false) {
         let relatedAlertDefinitions = definitions
             .filter((v) => this.api.scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
@@ -271,5 +165,28 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: AlertRedux.AlertDefinitionEdit,
         };
     }
+    toView(alert) {
+        return {
+            items: [
+                getScopeViewItems_1.getScopeViewItems(alert.Scope),
+                getRuleViewItems_1.getRuleViewItems(alert.Rule, this.api),
+                getAlertBehaviourViewItems_1.getAlertBehaviourViewItems(),
+                getAlertPreviewViewItems_1.getAlertPreviewViewItems(alert, this.api),
+            ],
+            abObject: alert,
+        };
+    }
+    toViewAll() {
+        return this.api.alertApi.getAlertDefinitions().map((alert) => this.toView(alert));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: AlertRedux.AlertDefinitionDelete,
+            getSuspendAction: AlertRedux.AlertDefinitionSuspend,
+            getUnSuspendAction: AlertRedux.AlertDefinitionUnSuspend,
+            emptyView: AlertEmptyView_1.AlertEmptyView,
+            getEditWizard: () => AlertWizard_1.AlertWizard,
+        };
+    }
 }
 exports.AlertModule = AlertModule;

package/src/Strategy/CalculatedColumnModule.d.ts

@@ -1,6 +1,8 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
+import * as CalculatedColumnRedux from '../Redux/ActionsReducers/CalculatedColumnRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { CalculatedColumn } from '../PredefinedConfig/CalculatedColumnState';
 import { IModule } from './Interface/IModule';
@@ -14,4 +16,30 @@ export declare class CalculatedColumnModule extends AdaptableModuleBase implemen
     getReferencedNamedQueryNames(calculatedColumn: CalculatedColumn): string[];
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<CalculatedColumn>;
+    toView(calculateColumn: CalculatedColumn): {
+        items: ({
+            name: string;
+            values: string[];
+        } | {
+            name: string;
+            label: string;
+            values: string[];
+        })[];
+        abObject: CalculatedColumn;
+    };
+    toViewAll(): {
+        items: ({
+            name: string;
+            values: string[];
+        } | {
+            name: string;
+            label: string;
+            values: string[];
+        })[];
+        abObject: CalculatedColumn;
+    }[];
+    getViewProperties(): {
+        getDeleteAction: (calculatedColumn: CalculatedColumn) => CalculatedColumnRedux.CalculatedColumnDeleteAction;
+        getEditWizard: () => (props: import("../View/CalculatedColumn/Wizard/CalculatedColumnWizard").CalculatedColumnWizardProps) => JSX.Element;
+    };
 }

package/src/Strategy/CalculatedColumnModule.js

@@ -6,6 +6,10 @@ const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const CalculatedColumnRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/CalculatedColumnRedux"));
 const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
+const getExpressionViewItems_1 = require("./Utilities/getExpressionViewItems");
+const CalculatedColumnWizard_1 = require("../View/CalculatedColumn/Wizard/CalculatedColumnWizard");
+const getCalculatedColumnSettingTags_1 = require("../View/CalculatedColumn/Utilities/getCalculatedColumnSettingTags");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensions/ArrayExtensions"));
 class CalculatedColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.CalculatedColumnModuleId, 'Calculated Column', 'calculated-column', 'CalculatedColumnPopup', 'Create bespoke columns whose cell value is derived dynamically from an Expression', api);
@@ -59,5 +63,35 @@ class CalculatedColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: CalculatedColumnRedux.CalculatedColumnEdit,
         };
     }
+    toView(calculateColumn) {
+        const settingsTags = getCalculatedColumnSettingTags_1.getCalculatedColumnSettingTags(calculateColumn.CalculatedColumnSettings);
+        let items = [
+            {
+                name: 'Settings',
+                label: 'Column Id',
+                values: [calculateColumn.ColumnId],
+            },
+            getExpressionViewItems_1.getExpressionViewItems(calculateColumn.Query),
+        ];
+        if (ArrayExtensions_1.default.IsNotNullOrEmpty(settingsTags)) {
+            items.push({
+                name: 'Settings',
+                values: settingsTags,
+            });
+        }
+        return {
+            items: items,
+            abObject: calculateColumn,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((calculatedColumn) => this.toView(calculatedColumn));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: CalculatedColumnRedux.CalculatedColumnDelete,
+            getEditWizard: () => CalculatedColumnWizard_1.CalculatedColumnWizard,
+        };
+    }
 }
 exports.CalculatedColumnModule = CalculatedColumnModule;

package/src/Strategy/ChartingModule.d.ts

@@ -0,0 +1,7 @@
+import { AdaptableModuleBase } from '@adaptabletools/adaptable/src/Strategy/AdaptableModuleBase';
+import { IModule } from '@adaptabletools/adaptable/src/Strategy/Interface/IModule';
+import { AdaptableApi } from '@adaptabletools/adaptable/src/Api/AdaptableApi';
+export declare class ChartingModule extends AdaptableModuleBase implements IModule {
+    constructor(api: AdaptableApi);
+    isModuleAvailable(): boolean;
+}

package/src/Strategy/ChartingModule.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartingModule = void 0;
+const tslib_1 = require("tslib");
+const AdaptableModuleBase_1 = require("@adaptabletools/adaptable/src/Strategy/AdaptableModuleBase");
+const ModuleConstants = tslib_1.__importStar(require("@adaptabletools/adaptable/src/Utilities/Constants/ModuleConstants"));
+class ChartingModule extends AdaptableModuleBase_1.AdaptableModuleBase {
+    constructor(api) {
+        super(ModuleConstants.ChartingModuleId, 'Charts', 'chart', 'ChartPopup', 'Create Charts in order to see Adaptable Data visually', api);
+    }
+    isModuleAvailable() {
+        return this.api.chartingApi.isChartingEnabled() && super.isModuleAvailable();
+    }
+}
+exports.ChartingModule = ChartingModule;

package/src/Strategy/ConditionalStyleModule.d.ts

@@ -1,11 +1,14 @@
+/// <reference types="react" />
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { ConditionalStyle } from '../PredefinedConfig/ConditionalStyleState';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
+import * as ConditionalStyleRedux from '../Redux/ActionsReducers/ConditionalStyleRedux';
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { IConditionalStyleModule } from './Interface/IConditionalStyleModule';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableObjectView } from './Interface/IModule';
 export declare class ConditionalStyleModule extends AdaptableModuleBase implements IConditionalStyleModule {
     constructor(api: AdaptableApi);
     getModuleAdaptableObjects(): AdaptableObject[];
@@ -19,4 +22,13 @@ export declare class ConditionalStyleModule extends AdaptableModuleBase implemen
     private evaluatePredicate;
     private evaluateExpression;
     private shouldRunStyle;
+    toView(conditionalStyle: ConditionalStyle): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (conditionalStyle: ConditionalStyle) => ConditionalStyleRedux.ConditionalStyleAction;
+        getSuspendAction: (conditionalStyle: ConditionalStyle) => ConditionalStyleRedux.ConditionalStyleSuspendAction;
+        getUnSuspendAction: (conditionalStyle: ConditionalStyle) => ConditionalStyleRedux.ConditionalStyleUnSuspendAction;
+        emptyView: string;
+        getEditWizard(): import("react").FunctionComponent<import("../View/ConditionalStyle/Wizard/ConditionalStyleWizard").ConditionalStyleWizardProps>;
+    };
 }

package/src/Strategy/ConditionalStyleModule.js

@@ -8,6 +8,10 @@ const ArrayExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensio
 const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants_1 = require("../Utilities/Constants/ModuleConstants");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const ConditionalStyleWizard_1 = require("../View/ConditionalStyle/Wizard/ConditionalStyleWizard");
+const getRuleViewItems_1 = require("./Utilities/getRuleViewItems");
+const getStyleViewItems_1 = require("./Utilities/getStyleViewItems");
 class ConditionalStyleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.ConditionalStyleModuleId, 'Conditional Style', 'conditional-style', 'ConditionalStylePopup', 'Style columns and rows dynamically based on rules and cell values', api);
@@ -181,5 +185,29 @@ class ConditionalStyleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
         return true;
     }
+    toView(conditionalStyle) {
+        return {
+            items: [
+                getScopeViewItems_1.getScopeViewItems(conditionalStyle.Scope),
+                getStyleViewItems_1.getStyleViewItems(),
+                getRuleViewItems_1.getRuleViewItems(conditionalStyle.Rule, this.api),
+            ],
+            abObject: conditionalStyle,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((conditionalStyle) => this.toView(conditionalStyle));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: (conditionalStyle) => ConditionalStyleRedux.ConditionalStyleDelete(conditionalStyle),
+            getSuspendAction: (conditionalStyle) => ConditionalStyleRedux.ConditionalStyleSuspend(conditionalStyle),
+            getUnSuspendAction: (conditionalStyle) => ConditionalStyleRedux.ConditionalStyleUnSuspend(conditionalStyle),
+            emptyView: "Click 'New' to create a new Conditional Style Rule.  When this is met, row or cells in the Conditional Style's scope will be styled appropriately.",
+            getEditWizard() {
+                return ConditionalStyleWizard_1.ConditionalStyleWizard;
+            },
+        };
+    }
 }
 exports.ConditionalStyleModule = ConditionalStyleModule;

package/src/Strategy/CustomSortModule.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { CustomSort } from '../PredefinedConfig/CustomSortState';
+import * as CustomSortRedux from '../Redux/ActionsReducers/CustomSortRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
-import { IModule } from './Interface/IModule';
+import { AdaptableObjectView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 export declare class CustomSortModule extends AdaptableModuleBase implements IModule {
@@ -13,4 +15,13 @@ export declare class CustomSortModule extends AdaptableModuleBase implements IMo
     hasNamedQueryReferences(): boolean;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<CustomSort>;
+    toView(customSort: CustomSort): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (customSort: CustomSort) => CustomSortRedux.CustomSortDeleteAction;
+        getSuspendAction: (customSort: CustomSort) => CustomSortRedux.CustomSortDeleteAction;
+        getUnSuspendAction: (customSort: CustomSort) => CustomSortRedux.CustomSortDeleteAction;
+        emptyView: string;
+        getEditWizard(): (props: import("../View/CustomSort/Wizard/CustomSortWizard").CustomSortWizardProps) => JSX.Element;
+    };
 }

package/src/Strategy/CustomSortModule.js

@@ -5,6 +5,9 @@ const tslib_1 = require("tslib");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const CustomSortRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/CustomSortRedux"));
+const CustomSortWizard_1 = require("../View/CustomSort/Wizard/CustomSortWizard");
+const getCustomSortColumnViewItems_1 = require("./Utilities/getCustomSortColumnViewItems");
+const getCustomSortSortOrderViewItems_1 = require("./Utilities/getCustomSortSortOrderViewItems");
 class CustomSortModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.CustomSortModuleId, 'Custom Sort', 'custom-sort', 'CustomSortPopup', 'Provide bespoke sorting information for Columns (in place of alphabetical sorting)', api);
@@ -46,5 +49,28 @@ class CustomSortModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: CustomSortRedux.CustomSortEdit,
         };
     }
+    toView(customSort) {
+        return {
+            items: [
+                getCustomSortColumnViewItems_1.getCustomSortColumnViewItems(customSort, this.api),
+                getCustomSortSortOrderViewItems_1.getCustomSortSortOrderViewItems(customSort),
+            ],
+            abObject: customSort,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((customSort) => this.toView(customSort));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: CustomSortRedux.CustomSortDelete,
+            getSuspendAction: CustomSortRedux.CustomSortSuspend,
+            getUnSuspendAction: CustomSortRedux.CustomSortUnSuspend,
+            emptyView: "Click 'New' to create a custom Sort Order for a selected Column.",
+            getEditWizard() {
+                return CustomSortWizard_1.CustomSortWizard;
+            },
+        };
+    }
 }
 exports.CustomSortModule = CustomSortModule;

package/src/Strategy/DashboardModule.d.ts

@@ -4,7 +4,6 @@ import { IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 export declare class DashboardModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
-    addModuleMenuItem(source: 'ModuleMenu' | 'ModuleButton'): AdaptableMenuItem | undefined;
     updateOldConfig(): void;
     handleAdaptableReady(): void;
     addColumnMenuItems(): AdaptableMenuItem[] | undefined;

package/src/Strategy/DashboardModule.js

@@ -10,11 +10,6 @@ class DashboardModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.DashboardModuleId, 'Dashboard', 'dashboard', 'DashboardPopup', 'The Dashboard - usually placed above the Grid - is designed to provide quick access to commonly required AdapTable functionalty', api);
     }
-    // no standard module menu item as we do special ones in the Dashboard class
-    addModuleMenuItem(source) {
-        // dont need
-        return undefined;
-    }
     updateOldConfig() {
         let dashboardState = this.api.dashboardApi.getDashboardState();
         if (dashboardState.VisibleButtons) {
@@ -23,8 +18,7 @@ class DashboardModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
     }
     handleAdaptableReady() {
-        // create a default Dashboard tab if one not provided
-        this.api.internalApi.setDefaultDashboardTab();
+        // 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
         // therefore, we give them a head start to subscribe to 'DashboardChanged' before emitting it

package/src/Strategy/DataChangeHistoryModule.js

@@ -7,7 +7,7 @@ const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/Mod
 const SystemRedux_1 = require("../Redux/ActionsReducers/SystemRedux");
 class DataChangeHistoryModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
-        super(ModuleConstants.DataChangeHistoryModuleId, 'Data Change History', 'track-changes', 'DataChangeHistoryPopup', 'Provides an overview of all previous changes, giving the possibility to undo specific changes', api);
+        super(ModuleConstants.DataChangeHistoryModuleId, 'Data Changes', 'track-changes', 'DataChangeHistoryPopup', 'Provides an overview of all previous changes, giving the possibility to undo specific changes', api);
         this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
             if (dataChangedInfo.trigger !== 'undo') {
                 if (this.shouldLogDataChange(dataChangedInfo)) {

package/src/Strategy/DataSourceModule.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
+import * as DataSourceRedux from '../Redux/ActionsReducers/DataSourceRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { DataSource } from '../PredefinedConfig/DataSourceState';
-import { IModule } from './Interface/IModule';
+import { AdaptableObjectView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 export declare class DataSourceModule extends AdaptableModuleBase implements IModule {
@@ -9,4 +11,10 @@ export declare class DataSourceModule extends AdaptableModuleBase implements IMo
     getModuleAdaptableObjects(): AdaptableObject[];
     hasNamedQueryReferences(): boolean;
     getTeamSharingAction(): TeamSharingImportInfo<DataSource>;
+    toView(dataSource: DataSource): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (dataSource: DataSource) => DataSourceRedux.DataSourceDeleteAction;
+        getEditWizard: () => import("react").FunctionComponent<import("../View/DataSource/Wizard/DataSourceWizard").DataSourceWizardProps>;
+    };
 }

package/src/Strategy/DataSourceModule.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const DataSourceRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/DataSourceRedux"));
+const DataSourceWizard_1 = require("../View/DataSource/Wizard/DataSourceWizard");
 class DataSourceModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.DataSourceModuleId, 'Data Source', 'data-source', 'DataSourcePopup', 'Update the entire data set in AdapTable using pre-populated data sources', api);
@@ -22,5 +23,32 @@ class DataSourceModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: DataSourceRedux.DataSourceEdit,
         };
     }
+    toView(dataSource) {
+        var _a;
+        return {
+            items: [
+                {
+                    name: 'Settings',
+                    label: 'Name',
+                    values: [dataSource.Name],
+                },
+                {
+                    name: 'Settings',
+                    label: 'Description',
+                    values: [(_a = dataSource.Description) !== null && _a !== void 0 ? _a : 'Not Specified'],
+                },
+            ],
+            abObject: dataSource,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((dataSource) => this.toView(dataSource));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: DataSourceRedux.DataSourceDelete,
+            getEditWizard: () => DataSourceWizard_1.DataSourceWizard,
+        };
+    }
 }
 exports.DataSourceModule = DataSourceModule;

package/src/Strategy/ExportModule.d.ts

@@ -1,11 +1,14 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { IExportModule } from './Interface/IExportModule';
 import { ExportDestination } from '../PredefinedConfig/Common/Enums';
 import { Report } from '../PredefinedConfig/ExportState';
+import * as ExportRedux from '../Redux/ActionsReducers/ExportRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableObjectView } from './Interface/IModule';
 export declare class ExportModule extends AdaptableModuleBase implements IExportModule {
     constructor(api: AdaptableApi);
     getModuleAdaptableObjects(): AdaptableObject[];
@@ -24,4 +27,13 @@ export declare class ExportModule extends AdaptableModuleBase implements IExport
     getTeamSharingAction(): TeamSharingImportInfo<Report>;
     private isEmptyReportData;
     private showEmptyExportWarning;
+    toView(report: Report): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        actions: import("react").FunctionComponent<{
+            data: Report;
+        }>[];
+        getDeleteAction: (report: Report) => ExportRedux.ReportDeleteAction;
+        getEditWizard(): (props: import("../View/Export/Wizard/NewReportWizard").NewReportWizardProps) => JSX.Element;
+    };
 }