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

package/src/Strategy/FilterModule.d.ts

@@ -1,9 +1,10 @@
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 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 {
@@ -15,4 +16,10 @@ export declare class FilterModule extends AdaptableModuleBase implements IModule
     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);
@@ -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.js

@@ -13,13 +13,21 @@ class GridInfoModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     }
     addColumnMenuItems(column) {
         if (this.isModuleAvailable()) {
+            const showGridSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('GridSummary');
+            const showColumnInfoSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('ColumnInfo');
             let selectMenuItems = [];
-            selectMenuItems.push(this.createMainMenuItemShowPopup({
-                Label: 'Grid',
-                ComponentName: this.moduleInfo.Popup,
-                Icon: 'align-justify',
-            }));
-            if (column) {
+            if (showGridSection) {
+                selectMenuItems.push(this.createMainMenuItemShowPopup({
+                    Label: 'Grid',
+                    ComponentName: this.moduleInfo.Popup,
+                    Icon: 'align-justify',
+                }));
+            }
+            if (column && showColumnInfoSection) {
                 selectMenuItems.push(this.createMainMenuItemShowPopup({
                     Label: 'Column',
                     ComponentName: this.moduleInfo.Popup,
@@ -30,48 +38,62 @@ class GridInfoModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                     },
                 }));
             }
-            return [
-                {
-                    label: 'Show Info',
-                    isVisible: true,
-                    icon: this.moduleInfo.Glyph,
-                    subItems: selectMenuItems,
-                },
-            ];
+            if (showGridSection || showColumnInfoSection) {
+                return [
+                    {
+                        label: 'Show Info',
+                        isVisible: true,
+                        icon: this.moduleInfo.Glyph,
+                        subItems: selectMenuItems,
+                    },
+                ];
+            }
         }
     }
     addContextMenuItems(menuContext) {
         if (this.isModuleAvailable()) {
             let selectMenuItems = [];
+            const showGridSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('GridSummary');
+            const showColumnInfoSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('ColumnInfo');
             let gridPopUpParams = {
                 source: 'ContextMenu',
             };
-            selectMenuItems.push(this.createMainMenuItemShowPopup({
-                Label: 'Grid',
-                ComponentName: this.moduleInfo.Popup,
-                Icon: 'align-justify',
-                PopupParams: gridPopUpParams,
-            }));
-            if (!menuContext.isRowGroupColumn) {
-                let columnPopUpParams = {
-                    source: 'ContextMenu',
-                    column: menuContext.adaptableColumn,
-                };
+            if (showGridSection) {
                 selectMenuItems.push(this.createMainMenuItemShowPopup({
-                    Label: 'Column',
+                    Label: 'Grid',
                     ComponentName: this.moduleInfo.Popup,
-                    Icon: 'column-chooser',
-                    PopupParams: columnPopUpParams,
+                    Icon: 'align-justify',
+                    PopupParams: gridPopUpParams,
                 }));
             }
-            return [
-                {
-                    label: 'Show Info',
-                    isVisible: true,
-                    icon: this.moduleInfo.Glyph,
-                    subItems: selectMenuItems,
-                },
-            ];
+            if (showColumnInfoSection) {
+                if (!menuContext.isRowGroupColumn) {
+                    let columnPopUpParams = {
+                        source: 'ContextMenu',
+                        column: menuContext.adaptableColumn,
+                    };
+                    selectMenuItems.push(this.createMainMenuItemShowPopup({
+                        Label: 'Column',
+                        ComponentName: this.moduleInfo.Popup,
+                        Icon: 'column-chooser',
+                        PopupParams: columnPopUpParams,
+                    }));
+                }
+            }
+            if (showGridSection || showColumnInfoSection) {
+                return [
+                    {
+                        label: 'Show Info',
+                        isVisible: true,
+                        icon: this.moduleInfo.Glyph,
+                        subItems: selectMenuItems,
+                    },
+                ];
+            }
         }
     }
 }