@adaptabletools/adaptable 10.0.4-canary.1 → 10.0.4-canary.5

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,18 +1,21 @@
+/// <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, MenuContext } from '../PredefinedConfig/Common/Menu';
+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[];
     getExplicitlyReferencedColumnIds(report: Report): string[];
     getReferencedNamedQueryNames(report: Report): string[];
     updateOldConfig(): void;
-    addContextMenuItems(menuContext: MenuContext): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     export(report: Report, exportDestination: ExportDestination | string): void;
     private isCustomDestination;
     private convertReportToJSON;
@@ -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;
+    };
 }

package/src/Strategy/ExportModule.js

@@ -14,6 +14,10 @@ const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensions/StringExtensions"));
 const PopupRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/PopupRedux"));
 const ObjectFactory_1 = require("../Utilities/ObjectFactory");
+const NewReportWizard_1 = require("../View/Export/Wizard/NewReportWizard");
+const getExportColumnsViewItems_1 = require("./Utilities/getExportColumnsViewItems");
+const getExportRowsViewItems_1 = require("./Utilities/getExportRowsViewItems");
+const ReportExportDropdown_1 = require("../View/Export/ReportExportDropdown");
 class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.ExportModuleId, 'Export', 'export-data', 'ExportPopup', 'Export data from the Grid to numerous locations in numerous formatso', api);
@@ -186,5 +190,44 @@ class ExportModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             alertDefinition: ObjectFactory_1.ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
         }));
     }
+    toView(report) {
+        const isSystemReport = this.api.internalApi
+            .getReportService()
+            .IsSystemReport(report.Name);
+        if (isSystemReport) {
+            return {
+                items: [
+                    {
+                        name: 'Report',
+                        values: [report.Name],
+                    },
+                ],
+                abObject: report,
+            };
+        }
+        return {
+            items: [
+                {
+                    name: 'Report',
+                    values: [report.Name],
+                },
+                getExportColumnsViewItems_1.getExportColumnsViewItems(report, this.api),
+                getExportRowsViewItems_1.getExportRowsViewItems(report, this.api),
+            ],
+            abObject: report,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((report) => this.toView(report));
+    }
+    getViewProperties() {
+        return {
+            actions: [ReportExportDropdown_1.ReportExportDropdown],
+            getDeleteAction: ExportRedux.ReportDelete,
+            getEditWizard() {
+                return NewReportWizard_1.NewReportWizard;
+            },
+        };
+    }
 }
 exports.ExportModule = ExportModule;

package/src/Strategy/FilterModule.d.ts

@@ -1,9 +1,10 @@
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableMenuItem, MenuContext } from '../PredefinedConfig/Common/Menu';
+import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
+import * as FilterRedux from '../Redux/ActionsReducers/FilterRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { ColumnFilter } from '../PredefinedConfig/FilterState';
-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 FilterModule extends AdaptableModuleBase implements IModule {
@@ -12,7 +13,13 @@ export declare class FilterModule extends AdaptableModuleBase implements IModule
     getExplicitlyReferencedColumnIds(columnFilter: ColumnFilter): string[];
     hasNamedQueryReferences(): boolean;
     handleAdaptableReady(): void;
-    addContextMenuItems(menuContext: MenuContext): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<ColumnFilter>;
+    toView(filter: ColumnFilter): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (columnFilter: ColumnFilter) => FilterRedux.ColumnFilterClearAction;
+        emptyView: string;
+    };
 }

package/src/Strategy/FilterModule.js

@@ -76,5 +76,32 @@ class FilterModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: FilterRedux.ColumnFilterEdit,
         };
     }
+    toView(filter) {
+        return {
+            items: [
+                {
+                    name: 'Column',
+                    values: [filter.ColumnId],
+                },
+                {
+                    name: 'Filter',
+                    values: [this.api.filterApi.columnFilterToString(filter)],
+                },
+            ],
+            abObject: filter,
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((filter) => this.toView(filter));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: FilterRedux.ColumnFilterClear,
+            emptyView: `
+        There are currently no column filters applied.
+        Create column filters by using the filter dropdown in each column header.
+      `,
+        };
+    }
 }
 exports.FilterModule = FilterModule;

package/src/Strategy/FlashingCellModule.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
+import { DataChangedInfo } from '../PredefinedConfig/Common/DataChangedInfo';
+import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
+import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
+import * as FlashingCellRedux from '../Redux/ActionsReducers/FlashingCellRedux';
+import { AdaptableModuleBase } from './AdaptableModuleBase';
+import { AdaptableObjectView, IModule } from './Interface/IModule';
+import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { FlashingCellDefinition } from '../PredefinedConfig/FlashingCellState';
+export declare class FlashingCellModule extends AdaptableModuleBase implements IModule {
+    constructor(api: AdaptableApi);
+    getModuleAdaptableObjects(): AdaptableObject[];
+    getExplicitlyReferencedColumnIds(alertDefinition: FlashingCellDefinition): string[];
+    getReferencedNamedQueryNames(alertDefinition: FlashingCellDefinition): string[];
+    addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
+    protected handleDataSourceChanged(dataChangedInfo: DataChangedInfo): void;
+    private showFlashingCellsForDefinitions;
+    private getFlashingCellDefinitionsForDataChange;
+    private getBaseAlertDefinitionsForDataChange;
+    private isAlertPredicateTriggered;
+    getTeamSharingAction(): TeamSharingImportInfo<FlashingCellDefinition>;
+    toView(flashingCell: FlashingCellDefinition): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getSuspendAction: (flashingCellDefinition: FlashingCellDefinition) => FlashingCellRedux.FlashingCellDefinitionEditAction;
+        getUnSuspendAction: (flashingCellDefinition: FlashingCellDefinition) => FlashingCellRedux.FlashingCellDefinitionEditAction;
+        getDeleteAction: (flashingCellDefinition: FlashingCellDefinition) => FlashingCellRedux.FlashingCellDefinitionDeleteAction;
+        getEditWizard: () => (props: import("../View/FlashingCell/Wizard/FlashingCellWizard").FlashingCellWizardProps) => JSX.Element;
+    };
+}

package/src/Strategy/FlashingCellModule.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashingCellModule = void 0;
+const tslib_1 = require("tslib");
+const FlashingCellRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/FlashingCellRedux"));
+const SystemRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/SystemRedux"));
+const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
+const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
+const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
+const AdaptableQuery_1 = require("../PredefinedConfig/Common/AdaptableQuery");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const getRuleViewItems_1 = require("./Utilities/getRuleViewItems");
+const getFlashingCellDurationViewItems_1 = require("./Utilities/getFlashingCellDurationViewItems");
+const getFlashingCellStyleViewItems_1 = require("./Utilities/getFlashingCellStyleViewItems");
+const FlashingCellWizard_1 = require("../View/FlashingCell/Wizard/FlashingCellWizard");
+class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
+    constructor(api) {
+        super(ModuleConstants.FlashingCellModuleId, 'Flashing Cell', 'flashing-cell', 'FlashingAlert', 'Flash cells when they change', api);
+        this.api.internalApi.getDataService().on('DataChanged', (dataChangedInfo) => {
+            if (dataChangedInfo.trigger === 'undo') {
+                // do NOT handle reverted changes
+                return;
+            }
+            // TODO: think about flashing row value only
+            // - flash for the underlying small data changes, but the visual does not
+            if (this.api.internalApi.getAdaptableOptions().notificationsOptions
+                .dataChangeDetectionPolicy === 'formattedValue') {
+                const { oldValue, newValue } = dataChangedInfo;
+                const columnId = dataChangedInfo.column.columnId;
+                const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, oldValue);
+                const newFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(columnId, newValue);
+                if (oldFormattedValue === newFormattedValue) {
+                    // if the formattedValues are identical, then no alert is fired
+                    return;
+                }
+            }
+            this.handleDataSourceChanged(dataChangedInfo);
+        });
+    }
+    getModuleAdaptableObjects() {
+        return this.api.flashingCellApi.getFlashingCellDefinitions();
+    }
+    getExplicitlyReferencedColumnIds(alertDefinition) {
+        const queryExpression = AdaptableQuery_1.getAdaptableQueryExpression(alertDefinition.Rule);
+        if (queryExpression) {
+            return this.api.queryLanguageApi.getColumnsFromExpression(queryExpression);
+        }
+        else if (this.api.scopeApi.scopeHasColumns(alertDefinition.Scope)) {
+            return this.api.scopeApi
+                .getColumnsForScope(alertDefinition.Scope)
+                .map((adaptableColumn) => adaptableColumn.columnId);
+        }
+        return [];
+    }
+    getReferencedNamedQueryNames(alertDefinition) {
+        const queryExpression = AdaptableQuery_1.getAdaptableQueryExpression(alertDefinition.Rule);
+        if (!queryExpression) {
+            return [];
+        }
+        return this.api.queryApi.getReferencedNamedQueryNames(queryExpression);
+    }
+    addColumnMenuItems(column) {
+        if (column && this.isModuleEditable()) {
+            if (!this.api.columnApi.isCalculatedColumn(column.columnId)) {
+                const flashingCellDefinitions = this.api.flashingCellApi.getFlashingCellDefinitions();
+                const flashingCellForCurrentColumn = flashingCellDefinitions.find((flashingCellDefinition) => {
+                    return this.api.scopeApi.isColumnInScope(column, flashingCellDefinition.Scope);
+                });
+                if (flashingCellForCurrentColumn) {
+                    return [
+                        this.createColumnMenuItemReduxAction('Remove Flashing Cell', this.moduleInfo.Glyph, FlashingCellRedux.FlashingCellDefinitionDelete(flashingCellForCurrentColumn)),
+                    ];
+                }
+                return [
+                    this.createColumnMenuItemReduxAction('Add Flashing Cell', this.moduleInfo.Glyph, FlashingCellRedux.FlashingCellDefinitionAdd({
+                        Scope: {
+                            ColumnIds: [column.columnId],
+                        },
+                        Rule: {
+                            Predicate: { PredicateId: 'Any' },
+                        },
+                    })),
+                ];
+            }
+        }
+    }
+    addContextMenuItems(menuContext) {
+        const items = [];
+        if (!menuContext.isRowGroupColumn && this.isModuleAvailable()) {
+            if (menuContext.adaptableColumn && menuContext.rowNode) {
+                const flashingCellForRow = this.api.internalApi.getAdaptableFlashingCellFor(menuContext.primaryKeyValue);
+                const flashingCellForCell = this.api.internalApi.getAdaptableFlashingCellFor(menuContext.primaryKeyValue, menuContext.adaptableColumn.columnId);
+                if (flashingCellForRow && flashingCellForRow.flashTarget === 'row') {
+                    items.push(this.createColumnMenuItemReduxAction('Clear Flashing Alert for Row', this.moduleInfo.Glyph, SystemRedux.SystemFlashingCellDelete(flashingCellForRow)));
+                }
+                else if (flashingCellForCell && flashingCellForCell.flashTarget === 'cell') {
+                    items.push(this.createColumnMenuItemReduxAction('Clear Flashing Alert for Cell', this.moduleInfo.Glyph, SystemRedux.SystemFlashingCellDelete(flashingCellForCell)));
+                }
+            }
+        }
+        return items;
+    }
+    handleDataSourceChanged(dataChangedInfo) {
+        const flashingCellDefinitions = this.getFlashingCellDefinitionsForDataChange(dataChangedInfo);
+        if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(flashingCellDefinitions)) {
+            this.showFlashingCellsForDefinitions(dataChangedInfo, flashingCellDefinitions);
+        }
+    }
+    showFlashingCellsForDefinitions(dataChangedInfo, flashingCellDefinitions = []) {
+        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';
+        }
+        flashingCellDefinitions.forEach((flashingCellDefinition) => {
+            const flashTarget = this.api.flashingCellApi.getFlashingCellFlashTarget(flashingCellDefinition);
+            const flashColumnIds = { [dataChangedInfo.column.columnId]: true };
+            if (flashTarget === 'row') {
+                allColumnIds.forEach((colId) => {
+                    flashColumnIds[colId] = true;
+                });
+            }
+            const rowPrimaryKey = dataChangedInfo.primaryKeyValue;
+            this.api.flashingCellApi.showFlashingCell({
+                rowPrimaryKey,
+                flashingCellDefinition: flashingCellDefinition,
+                dataChangedInfo,
+                direction,
+                flashTarget,
+                flashColumnIds,
+            });
+        });
+    }
+    getFlashingCellDefinitionsForDataChange(dataChangedEvent) {
+        return this.getBaseAlertDefinitionsForDataChange(dataChangedEvent, 
+        // reactive flashing alert definitions are excluded as they are handled separately (asynchronously)
+        this.api.flashingCellApi.getActiveNonReactiveFlashingCellDefinitions(), true);
+    }
+    getBaseAlertDefinitionsForDataChange(dataChangedEvent, definitions, defaultNoPredicateReturn = false) {
+        let relatedAlertDefinitions = definitions
+            .filter((v) => this.api.scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
+            .filter((flashingCellDefinition) => !AdaptableQuery_1.isReactiveQuery(flashingCellDefinition.Rule));
+        let triggeredAlerts = [];
+        if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(relatedAlertDefinitions)) {
+            relatedAlertDefinitions.forEach((alertDefinition) => {
+                if (alertDefinition.Rule.BooleanExpression) {
+                    let expression = alertDefinition.Rule.BooleanExpression;
+                    let rowNode = dataChangedEvent.rowNode;
+                    if (!rowNode) {
+                        rowNode = this.api.gridApi.getRowNodeForPrimaryKey(dataChangedEvent.primaryKeyValue);
+                    }
+                    const isValidExpression = this.api.queryLanguageApi.isValidBooleanExpression(expression, this.moduleInfo.ModuleName, `Invalid Alert boolean expression '${expression}'`);
+                    const isSatisfiedExpression = isValidExpression &&
+                        this.api.internalApi
+                            .getQueryLanguageService()
+                            .evaluateBooleanExpression(expression, this.moduleInfo.ModuleName, rowNode);
+                    if (isSatisfiedExpression) {
+                        triggeredAlerts.push(alertDefinition);
+                    }
+                }
+                else if (this.isAlertPredicateTriggered(alertDefinition, dataChangedEvent, defaultNoPredicateReturn)) {
+                    triggeredAlerts.push(alertDefinition);
+                }
+            });
+        }
+        return triggeredAlerts;
+    }
+    isAlertPredicateTriggered(alert, dataChangedEvent, defaultNoPredicateReturn = false) {
+        return this.api.predicateApi.handlePredicate(alert.Rule.Predicate, {
+            value: dataChangedEvent.newValue,
+            oldValue: dataChangedEvent.oldValue,
+            // TODO send real display value
+            displayValue: null,
+            node: dataChangedEvent.rowNode,
+            column: dataChangedEvent.column,
+        }, defaultNoPredicateReturn);
+    }
+    getTeamSharingAction() {
+        return {
+            ModuleEntities: this.api.flashingCellApi.getFlashingCellDefinitions(),
+            AddAction: FlashingCellRedux.FlashingCellDefinitionAdd,
+            EditAction: FlashingCellRedux.FlashingCellDefinitionEdit,
+        };
+    }
+    toView(flashingCell) {
+        return {
+            items: [
+                getScopeViewItems_1.getScopeViewItems(flashingCell.Scope),
+                getRuleViewItems_1.getRuleViewItems(flashingCell.Rule, this.api),
+                getFlashingCellDurationViewItems_1.getFlashingCellDurationViewItems(flashingCell),
+                getFlashingCellStyleViewItems_1.getFlashingCellStyleViewItems(),
+            ],
+            abObject: flashingCell,
+        };
+    }
+    toViewAll() {
+        return this.api.flashingCellApi
+            .getFlashingCellDefinitions()
+            .map((flashingCell) => this.toView(flashingCell));
+    }
+    getViewProperties() {
+        return {
+            getSuspendAction: FlashingCellRedux.FlashingCellDefinitionSuspend,
+            getUnSuspendAction: FlashingCellRedux.FlashingCellDefinitionUnSuspend,
+            getDeleteAction: FlashingCellRedux.FlashingCellDefinitionDelete,
+            getEditWizard: () => FlashingCellWizard_1.FlashingCellWizard,
+        };
+    }
+}
+exports.FlashingCellModule = FlashingCellModule;

package/src/Strategy/FormatColumnModule.d.ts

@@ -2,10 +2,12 @@ import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
+import * as FormatColumnRedux from '../Redux/ActionsReducers/FormatColumnRedux';
 import { FormatColumn } from '../PredefinedConfig/FormatColumnState';
-import { IModule } from './Interface/IModule';
+import { AdaptableObjectView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { FormatColumnWizard } from '../View/FormatColumn/Wizard/FormatColumnWizard';
 export declare class FormatColumnModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
     getModuleAdaptableObjects(): AdaptableObject[];
@@ -15,4 +17,12 @@ export declare class FormatColumnModule extends AdaptableModuleBase implements I
     private getExistingFormatColumn;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<FormatColumn>;
+    toView(formatColumn: FormatColumn): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (formatColumn: FormatColumn) => FormatColumnRedux.FormatColumnDeleteAction;
+        getSuspendAction: (formatColumn: FormatColumn) => FormatColumnRedux.FormatColumnSuspendAction;
+        getUnSuspendAction: (formatColumn: FormatColumn) => FormatColumnRedux.FormatColumnSuspendAction;
+        getEditWizard(): typeof FormatColumnWizard;
+    };
 }

package/src/Strategy/FormatColumnModule.js

@@ -7,6 +7,11 @@ const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/Mod
 const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
 const FormatColumnRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/FormatColumnRedux"));
 const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
+const FormatColumnWizard_1 = require("../View/FormatColumn/Wizard/FormatColumnWizard");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const FormatColumnStyleWizardSection_1 = require("../View/FormatColumn/Wizard/FormatColumnStyleWizardSection");
+const FormatColumnFormatWizardSection_1 = require("../View/FormatColumn/Wizard/FormatColumnFormatWizardSection");
+const getFormatColumnSettingsViewItems_1 = require("./Utilities/getFormatColumnSettingsViewItems");
 class FormatColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.FormatColumnModuleId, 'Format Column', 'format-column', 'FormatColumnPopup', 'Create a column style, display format or cell alignment', api);
@@ -133,7 +138,7 @@ class FormatColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         if (formatColumn) {
             return formatColumn;
         }
-        // special columns (CalculatedColumn & FreeTextColumns) are not yet part of the underlying AG-Grid colDefs
+        // special columns (Calculated, FreeText, Action) are not yet part of AG-GridS colDefs
         // so we have to check if the given columnId is a special column
         const isSpecialColumn = !!this.api.calculatedColumnApi.getCalculatedColumnForColumnId(columnId) ||
             !!this.api.freeTextColumnApi.getFreeTextColumnById(columnId);
@@ -209,5 +214,35 @@ class FormatColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: FormatColumnRedux.FormatColumnEdit,
         };
     }
+    toView(formatColumn) {
+        return {
+            abObject: formatColumn,
+            items: [
+                getScopeViewItems_1.getScopeViewItems(formatColumn.Scope),
+                {
+                    name: 'Style',
+                    view: () => FormatColumnStyleWizardSection_1.renderFormatColumnStyleSummary(formatColumn, this.api),
+                },
+                {
+                    name: 'Display Format',
+                    values: [FormatColumnFormatWizardSection_1.getFormatColumnFormatSummaryValue(formatColumn)],
+                },
+                getFormatColumnSettingsViewItems_1.getFormatColumnSettingsViewItems(formatColumn),
+            ],
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((formatColumn) => this.toView(formatColumn));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: FormatColumnRedux.FormatColumnDelete,
+            getSuspendAction: FormatColumnRedux.FormatColumnSuspend,
+            getUnSuspendAction: FormatColumnRedux.FormatColumnUnSuspend,
+            getEditWizard() {
+                return FormatColumnWizard_1.FormatColumnWizard;
+            },
+        };
+    }
 }
 exports.FormatColumnModule = FormatColumnModule;

package/src/Strategy/FreeTextColumnModule.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
+import * as FreeTextColumnRedux from '../Redux/ActionsReducers/FreeTextColumnRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
-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 FreeTextColumnModule extends AdaptableModuleBase implements IModule {
@@ -13,4 +15,10 @@ export declare class FreeTextColumnModule extends AdaptableModuleBase implements
     hasNamedQueryReferences(): boolean;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<FreeTextColumn>;
+    toView(freeTextColumn: FreeTextColumn): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (freeTextColumn: FreeTextColumn) => FreeTextColumnRedux.FreeTextColumnDeleteAction;
+        getEditWizard(): (props: import("../View/FreeTextColumn/Wizard/FreeTextColumnWizard").FreeTextColumnWizardProps) => JSX.Element;
+    };
 }

package/src/Strategy/FreeTextColumnModule.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 FreeTextColumnRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/FreeTextColumnRedux"));
+const FreeTextColumnWizard_1 = require("../View/FreeTextColumn/Wizard/FreeTextColumnWizard");
 class FreeTextColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.FreeTextColumnModuleId, 'Free Text Column', 'freetext-column', 'FreeTextColumnPopup', 'Dynamic column showing custom content (stored in state and not with grid data)', api);
@@ -43,5 +44,49 @@ class FreeTextColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: FreeTextColumnRedux.FreeTextColumnEdit,
         };
     }
+    toView(freeTextColumn) {
+        var _a;
+        return {
+            abObject: freeTextColumn,
+            items: [
+                {
+                    name: 'Settings',
+                    label: 'Column Id',
+                    values: [freeTextColumn.ColumnId],
+                },
+                freeTextColumn.FriendlyName && {
+                    name: 'Settings',
+                    label: 'Column Name',
+                    values: [freeTextColumn.FriendlyName],
+                },
+                {
+                    name: 'Settings',
+                    label: 'Data Type',
+                    values: [(_a = freeTextColumn.DataType) !== null && _a !== void 0 ? _a : 'Not specified'],
+                },
+                freeTextColumn.DefaultValue !== undefined && {
+                    name: 'Settings',
+                    label: 'Default Value',
+                    values: [freeTextColumn.DefaultValue],
+                },
+                freeTextColumn.TextEditor && {
+                    name: 'Editor Type',
+                    label: 'Editor',
+                    values: [freeTextColumn.TextEditor],
+                },
+            ].filter(Boolean),
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((freeTextColumn) => this.toView(freeTextColumn));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: FreeTextColumnRedux.FreeTextColumnDelete,
+            getEditWizard() {
+                return FreeTextColumnWizard_1.FreeTextColumnWizard;
+            },
+        };
+    }
 }
 exports.FreeTextColumnModule = FreeTextColumnModule;

package/src/Strategy/GridInfoModule.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableModuleBase } from './AdaptableModuleBase';
-import { AdaptableMenuItem, MenuContext } from '../PredefinedConfig/Common/Menu';
+import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
@@ -8,5 +8,5 @@ export declare class GridInfoModule extends AdaptableModuleBase implements IModu
     constructor(api: AdaptableApi);
     getViewAccessLevel(): AccessLevel;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
-    addContextMenuItems(menuContext: MenuContext): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
 }