@adaptabletools/adaptable 12.0.6 → 12.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "12.0.6",
+  "version": "12.0.9",
   "description": "Powerful data-agnostic HTML5 datagrid add-on that sits on top of an underlying grid component and provides all the rich functionality that advanced users expect from their DataGrids and Data Tables",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1657449987893;
+declare const _default: 1657803750403;
 export default _default;

package/publishTimestamp.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 1657449987893;
+exports.default = 1657803750403;

package/src/Api/EventApi.d.ts

@@ -16,6 +16,7 @@ import { GridDataChangedInfo } from './Events/GridDataChanged';
 import { TeamSharingEntityChangedInfo } from './Events/TeamSharingEntityChanged';
 import { ActionRowSubmittedInfo } from './Events/ActionRowSubmitted';
 import { DataSetSelectedInfo } from './Events/DataSetSelected';
+import { AdaptableStateReloadedInfo } from './Events/AdaptableStateReloaded';
 /**
  * Responsible for publishing the many Events that AdapTable fires
  */
@@ -183,6 +184,17 @@ export interface EventApi {
      * Unsubscribe from AdaptableStateChanged
      */
     off(eventName: 'AdaptableStateChanged', callback: (adaptableStateChangedInfo: AdaptableStateChangedInfo) => void): void;
+    /**
+     * Event fired whenever **Adaptable State is reloaded**
+     * @param eventName AdaptableStateReloaded
+     * @param callback AdaptableStateReloadedInfo
+     * @returns the unsubscribe function
+     */
+    on(eventName: 'AdaptableStateReloaded', callback: (adaptableStateReloadedInfo: AdaptableStateReloadedInfo) => void): () => void;
+    /**
+     * Unsubscribe from AdaptableStateReloaded
+     */
+    off(eventName: 'AdaptableStateReloaded', callback: (adaptableStateReloadedInfo: AdaptableStateReloadedInfo) => void): void;
     /**
      * Event fired whenever **a change occurs relating to live reports / data**
      * Used in conjunction with AdapTable's partners OpenFin, ipushpull or Glue42
@@ -252,6 +264,6 @@ export interface EventApi {
     emitSync(eventName: 'DashboardChanged', data?: any): any[];
     emitSync(eventName: 'FlashingCellDisplayed', data?: any): any[];
     emitSync(eventName: 'AdaptableDestroy'): any[];
-    emit(eventName: 'AdaptableReady' | 'AlertFired' | 'CheckboxColumnClicked' | 'CustomToolbarConfigured' | 'AdaptableStateChanged' | 'DashboardChanged' | 'CellChanged' | 'GridDataChanged' | 'LayoutChanged' | 'LiveDataChanged' | 'SearchChanged' | 'SelectionChanged' | 'SystemStatusMessageDisplayed' | 'TeamSharingEntityChanged' | 'ThemeChanged' | 'FDC3MessageSent' | 'ActionRowSubmitted' | 'DataSetSelected', data?: any): Promise<any>;
+    emit(eventName: 'AdaptableReady' | 'AlertFired' | 'CheckboxColumnClicked' | 'CustomToolbarConfigured' | 'AdaptableStateChanged' | 'AdaptableStateReloaded' | 'DashboardChanged' | 'CellChanged' | 'GridDataChanged' | 'LayoutChanged' | 'LiveDataChanged' | 'SearchChanged' | 'SelectionChanged' | 'SystemStatusMessageDisplayed' | 'TeamSharingEntityChanged' | 'ThemeChanged' | 'FDC3MessageSent' | 'ActionRowSubmitted' | 'DataSetSelected', data?: any): Promise<any>;
     destroy(): void;
 }

package/src/Api/Events/AdaptableStateReloaded.d.ts

@@ -0,0 +1,23 @@
+import { AdaptablePersistentState } from '../../PredefinedConfig/AdaptableState';
+import { BaseEventInfo } from './BaseEventInfo';
+/**
+ * Object returned by the `AdaptableStateReloaded` event
+ */
+export interface AdaptableStateReloadedInfo extends BaseEventInfo {
+    /**
+     * Current AdapTableId
+     */
+    adaptableId: string;
+    /**
+     * Current Adaptable State Key
+     */
+    adaptableStateKey: string;
+    /**
+     * Adaptable State before the reload
+     */
+    oldState: AdaptablePersistentState;
+    /**
+     * Adaptable State after the reload
+     */
+    newState: AdaptablePersistentState;
+}

package/src/Api/Events/AdaptableStateReloaded.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Api/GridApi.d.ts

@@ -261,8 +261,9 @@ export interface GridApi {
      * Retrieves Formatted Value for a given Raw Value in given Column
      * @param columnId ColumnId to lookup
      * @param rawValue Raw Value
+     * @param rowNode Node containig the Column
      */
-    getFormattedValueFromRawValue(rowNode: RowNode, columnId: string, rawValue: any): string | undefined;
+    getDisplayValueFromRawValue(rowNode: RowNode, columnId: string, rawValue: any): string | undefined;
     /**
      * Retrieves Display Value for Cell in given Row and Column
      * @param rowNode Row to use

package/src/Api/Implementation/ConfigApiImpl.js

@@ -48,6 +48,7 @@ class ConfigApiImpl extends ApiBase_1.ApiBase {
     reloadPredefinedConfig(newPredefinedConfig) {
         var _a;
         const adaptableOptions = this.adaptable.adaptableOptions;
+        const oldState = this.getPersistedState();
         const clearStateFn = ((_a = adaptableOptions.stateOptions) === null || _a === void 0 ? void 0 : _a.clearState) ||
             (() => {
                 localStorage.removeItem(adaptableOptions.adaptableStateKey);
@@ -63,6 +64,16 @@ class ConfigApiImpl extends ApiBase_1.ApiBase {
                 this.setAdaptableStateKey(adaptableOptions.adaptableStateKey, {
                     predefinedConfig: newPredefinedConfig || adaptableOptions.predefinedConfig,
                     flushCurrentState: false,
+                }).then(() => {
+                    const newState = this.getPersistedState();
+                    const stateReloadedInfo = {
+                        oldState,
+                        newState,
+                        adaptableStateKey: adaptableOptions.adaptableStateKey,
+                        adaptableId: adaptableOptions.adaptableId,
+                        adaptableApi: this.adaptable.api,
+                    };
+                    this.adaptable.api.eventApi.emit('AdaptableStateReloaded', stateReloadedInfo);
                 });
             });
         });

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -65,7 +65,7 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     getGridCellFromRowNode(rowNode: RowNode, columnId: string): GridCell | undefined;
     getRawValueFromRowNode(rowNode: RowNode, columnId: string): any | undefined;
     getDisplayValueFromRowNode(rowNode: RowNode, columnId: string): any | undefined;
-    getFormattedValueFromRawValue(rowNode: RowNode, columnId: string, rawValue: any): string | undefined;
+    getDisplayValueFromRawValue(rowNode: RowNode, columnId: string, rawValue: any): string | undefined;
     getNormalisedValueFromRowNode(rowNode: RowNode, columnId: string): any | undefined;
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): RowNode[];
     getRowNodeForPrimaryKey(primaryKeyValue: any): RowNode;

package/src/Api/Implementation/GridApiImpl.js

@@ -200,7 +200,7 @@ class GridApiImpl extends ApiBase_1.ApiBase {
     getDisplayValueFromRowNode(rowNode, columnId) {
         return this.adaptable.getDisplayValueFromRowNode(rowNode, columnId);
     }
-    getFormattedValueFromRawValue(rowNode, columnId, rawValue) {
+    getDisplayValueFromRawValue(rowNode, columnId, rawValue) {
         return this.adaptable.getDisplayValueFromRawValue(rowNode, columnId, rawValue);
     }
     getNormalisedValueFromRowNode(rowNode, columnId) {

package/src/Api/Implementation/InternalApiImpl.js

@@ -390,6 +390,9 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
     getQueryPreviewData() {
         var _a;
         const firstRowNode = this.adaptable.api.gridApi.getFirstRowNode();
+        if (firstRowNode == undefined) {
+            return {};
+        }
         const firstRowData = (_a = Object.assign({}, firstRowNode === null || firstRowNode === void 0 ? void 0 : firstRowNode.data)) !== null && _a !== void 0 ? _a : {};
         // handle CalcCols which are not persisted in the rowModel
         this.adaptable.api.calculatedColumnApi.getAllCalculatedColumn().forEach((calculatedColumn) => {

package/src/PredefinedConfig/Common/CellSummary.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableApi } from '../../Api/AdaptableApi';
+import { BaseContext } from '../../../types';
 import { SelectedCellInfo } from '../Selection/SelectedCellInfo';
 /**
  * Defines the Summary operations provides for Selected Cells
@@ -30,7 +30,7 @@ export interface CellSummaryOperation {
 /**
  * Context provided to a custom Cell Summary Operation function
  */
-export interface CellSummaryOperationContext {
+export interface CellSummaryOperationContext extends BaseContext {
     /**
      * Currently selected cells
      */
@@ -51,8 +51,4 @@ export interface CellSummaryOperationContext {
      * Count of currently selected cells
      */
     distinctCount: number;
-    /**
-     * Adaptable Api object
-     */
-    api: AdaptableApi;
 }

package/src/Redux/Store/AdaptableStore.js

@@ -570,7 +570,7 @@ const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
                             .getCalculatedColumnExpressionService()
                             .createAggregatedScalarCalculatedColumn(calculatedColumn);
                     });
-                    // refresh calcualted columns
+                    // refresh calculated columns
                     const aggCalculatedColumnIds = aggregatedCalculatedColumns.map((calculatedColumn) => calculatedColumn.ColumnId);
                     adaptable.refreshCells(null, aggCalculatedColumnIds, true);
                     return;

package/src/Strategy/AdaptableModuleBase.d.ts

@@ -12,6 +12,7 @@ import { AccessLevel } from '../PredefinedConfig/Common/Entitlement';
 import { CalculatedColumn } from '../PredefinedConfig/CalculatedColumnState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
 import { AdaptableInternalIconName } from '../PredefinedConfig/Common/AdaptableIcon';
+import { AdaptableStateReloadedInfo } from '../Api/Events/AdaptableStateReloaded';
 /**
  * Base class for all strategies and does most of the work of creating menus
  */
@@ -34,6 +35,7 @@ export declare abstract class AdaptableModuleBase implements IModule {
     getReferencedNamedQueryNames(adaptableObject: AdaptableObject): string[];
     hasNamedQueryReferences(): boolean;
     handleAdaptableReady(): void;
+    handleConfigReloaded(adaptableStateReloadedInfo: AdaptableStateReloadedInfo): void;
     setModuleEntitlement(): void;
     addModuleMenuItem(source: 'ModuleMenu' | 'ModuleButton'): AdaptableMenuItem | undefined;
     addModuleButtonMenuItem(): AdaptableMenuItem | undefined;

package/src/Strategy/AdaptableModuleBase.js

@@ -24,6 +24,9 @@ class AdaptableModuleBase {
             this.handleAdaptableReady();
             this.api.configApi.dispatchStateReadyAction(this.moduleInfo.ModuleName);
         });
+        this.api.eventApi.on('AdaptableStateReloaded', (adaptableStateReloadedInfo) => {
+            this.handleConfigReloaded(adaptableStateReloadedInfo);
+        });
     }
     getViewAccessLevel() {
         // override where necessary (ex. only 'Full' accessLevel should be displayed)
@@ -68,6 +71,9 @@ class AdaptableModuleBase {
     handleAdaptableReady() {
         // override where necessary in base classes
     }
+    handleConfigReloaded(adaptableStateReloadedInfo) {
+        // override where necessary in base classes
+    }
     setModuleEntitlement() {
         this.AccessLevel = this.api.internalApi
             .getEntitlementService()

package/src/Strategy/AlertModule.js

@@ -32,8 +32,8 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 'formattedValue') {
                 const { oldValue, newValue, rowNode } = cellDataChangedInfo;
                 const columnId = cellDataChangedInfo.column.columnId;
-                const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(rowNode, columnId, oldValue);
-                const newFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(rowNode, columnId, newValue);
+                const oldFormattedValue = this.api.gridApi.getDisplayValueFromRawValue(rowNode, columnId, oldValue);
+                const newFormattedValue = this.api.gridApi.getDisplayValueFromRawValue(rowNode, columnId, newValue);
                 if (oldFormattedValue === newFormattedValue) {
                     // if the formattedValues are identical, then no alert is fired
                     return;

package/src/Strategy/CalculatedColumnModule.d.ts

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

package/src/Strategy/CalculatedColumnModule.js

@@ -15,6 +15,10 @@ 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);
     }
+    handleConfigReloaded(adaptableStateReloadedInfo) {
+        // re-dispatch the CalculatedColumnReady action to recreate all the aggregated scalar columns
+        this.api.internalApi.dispatchReduxAction(CalculatedColumnRedux.CalculatedColumnReady(this.api.calculatedColumnApi.getCalculatedColumnState()));
+    }
     getModuleAdaptableObjects() {
         return this.api.calculatedColumnApi.getAllCalculatedColumn();
     }

package/src/Strategy/CellSummaryModule.js

@@ -98,14 +98,15 @@ class CellSummaryModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             const api = this.api;
             operationDefinitions === null || operationDefinitions === void 0 ? void 0 : operationDefinitions.forEach((operation) => {
                 if (operation.operationFunction) {
-                    selectedCellSummary[operation.operationName] = operation.operationFunction({
+                    const cellSummaryOperationContext = {
                         selectedCellInfo,
                         distinctCount,
                         allValues,
                         numericValues,
                         numericColumns,
-                        api,
-                    });
+                        adaptableApi: this.api,
+                    };
+                    selectedCellSummary[operation.operationName] = operation.operationFunction(cellSummaryOperationContext);
                 }
             });
         }

package/src/Strategy/FlashingCellModule.js

@@ -31,8 +31,8 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 'formattedValue') {
                 const { oldValue, newValue, rowNode } = cellDataChangedInfo;
                 const columnId = cellDataChangedInfo.column.columnId;
-                const oldFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(rowNode, columnId, oldValue);
-                const newFormattedValue = this.api.gridApi.getFormattedValueFromRawValue(rowNode, columnId, newValue);
+                const oldFormattedValue = this.api.gridApi.getDisplayValueFromRawValue(rowNode, columnId, oldValue);
+                const newFormattedValue = this.api.gridApi.getDisplayValueFromRawValue(rowNode, columnId, newValue);
                 if (oldFormattedValue === newFormattedValue) {
                     // if the formattedValues are identical, then no alert is fired
                     return;

package/src/Strategy/TeamSharingModule.js

@@ -32,10 +32,12 @@ class TeamSharingModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             // make sure there is no zombie import process remaining (in case a previous import crashed)
             this.api.internalApi.dispatchReduxAction(TeamSharingRedux.TeamSharingCommitImport());
         });
-        this.api.teamSharingApi.triggerLoadingTeamSharingEntries();
+        if (this.api.teamSharingApi.isTeamSharingAvailable()) {
+            this.api.teamSharingApi.triggerLoadingTeamSharingEntries();
+        }
     }
     isModuleAvailable() {
-        return super.isModuleAvailable() && this.api.teamSharingApi.isTeamSharingActivated();
+        return super.isModuleAvailable() && this.api.teamSharingApi.isTeamSharingAvailable();
     }
     isModuleObjectsShareable() {
         return false;

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -177,6 +177,11 @@ exports.aggregatedScalarExpressionFunctions = {
                                 }
                                 return rowValue < minValue ? rowValue : minValue;
                             },
+                            done: (minValue) => {
+                                if (minValue !== Number.MAX_VALUE) {
+                                    return minValue;
+                                }
+                            },
                         },
                     },
                 },
@@ -218,6 +223,11 @@ exports.aggregatedScalarExpressionFunctions = {
                                 }
                                 return rowValue > maxValue ? rowValue : maxValue;
                             },
+                            done: (maxValue) => {
+                                if (maxValue !== Number.MIN_VALUE) {
+                                    return maxValue;
+                                }
+                            },
                         },
                     },
                 },

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -29,6 +29,16 @@ class CalculatedColumnExpressionService {
                 this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
             }
         });
+        this.adaptableApi.eventApi.on('GridDataChanged', () => {
+            const refreshedCalculatedColumns = [];
+            this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
+                aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
+                refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
+            });
+            if (refreshedCalculatedColumns.length) {
+                this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
+            }
+        });
     }
     destroy() {
         [...this.aggregatedScalarCalculatedColumnsMap.values()].forEach((aggregatedScalarCalculatedColumn) => aggregatedScalarCalculatedColumn.destroy());
@@ -116,10 +126,7 @@ class CalculatedColumnExpressionService {
         // if there is already an aggregated scalar, delete it (possible when editing)
         this.destroyAggregatedScalarCalculatedColumn(calculatedColumn);
         if ((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.AggregatedScalarExpression) {
-            const aggregationConfig = this.adaptableApi.internalApi
-                .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
-            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(aggregationConfig.value, calculatedColumn, this.adaptableApi);
+            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(calculatedColumn, this.adaptableApi);
             this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
         }
     }
@@ -131,13 +138,16 @@ class CalculatedColumnExpressionService {
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
 class AggregatedScalarCalculatedColumn {
-    constructor(expressionEvaluation, calculatedColumn, adaptableApi) {
-        this.expressionEvaluation = expressionEvaluation;
+    constructor(calculatedColumn, adaptableApi) {
         this.calculatedColumn = calculatedColumn;
         this.adaptableApi = adaptableApi;
-        this.aggregationResult = this.computeAggregatedValue(expressionEvaluation);
+        const aggregationConfig = this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+        this.expressionEvaluation = aggregationConfig.value;
+        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
         // currently we support only one reducer
-        this.aggregationReducerName = Object.keys(expressionEvaluation.aggregationParams.reducers)[0];
+        this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
     }
     destroy() {
         this.expressionEvaluation = null;
@@ -153,6 +163,10 @@ class AggregatedScalarCalculatedColumn {
         return aggregationValue;
     }
     refreshAggregatedColumnValue() {
+        const aggregationConfig = this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .evaluateAggregatedScalarExpression(this.calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+        this.expressionEvaluation = aggregationConfig.value;
         this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
     }
     getCalculatedColumnId() {
@@ -167,11 +181,13 @@ class AggregatedScalarCalculatedColumn {
         // we iterate over the RowNode list (we need this to handle complex column values (nested values, valueGetters etc)
         // so we will map the fieldNames to RowNode.data
         const mapReducerValueGetter = (fieldName) => {
-            return (rowNode) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
+            return (rowNode) => {
+                return this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
+            };
         };
         Object.values(expressionEvaluation.aggregationParams.reducers).forEach((aggregationReducer) => {
             aggregationReducer.getter = mapReducerValueGetter(aggregationReducer.field);
-            // nullify the getter to force the fallback on the getter fn
+            // nullify the field to force the fallback on the getter fn
             aggregationReducer.field = null;
         });
         const mapGroupByToKey = (fieldName) => {

package/src/Utilities/Services/ReportService.js

@@ -339,7 +339,7 @@ class ReportService {
         return type === 'rawValue'
             ? cellRawValue
             : // type === formattedValue
-                this.adaptableApi.gridApi.getFormattedValueFromRawValue(rowNode, columnId, cellRawValue);
+                this.adaptableApi.gridApi.getDisplayValueFromRawValue(rowNode, columnId, cellRawValue);
     }
     computeCellExportValueFormat(columnDataType) {
         const exportOptions = this.adaptableApi.internalApi.getAdaptableOptions().exportOptions;

package/src/Utilities/Services/RowEditService.js

@@ -189,7 +189,10 @@ class RowEditService {
                     adaptableApi,
                 })
                 : Object.assign({}, formData);
-            adaptableApi.gridApi.addGridData([newRowData], { addIndex: 0 });
+            const config = {
+                addIndex: 0,
+            };
+            adaptableApi.gridApi.addGridData([newRowData], config);
         }
     }
 }

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableOptionsForm.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { AdaptableOptions } from '../../../types';
+interface AdaptableOptionsFormOptions {
+    adaptableOptions: AdaptableOptions;
+    onChangeadaptableOptions: (adaptableOptions: AdaptableOptions) => void;
+}
+declare const AdaptableOptionsForm: (props: AdaptableOptionsFormOptions) => JSX.Element;
+export default AdaptableOptionsForm;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/{ConfigurationForm.js → AdaptableOptionsForm.js}

@@ -8,17 +8,13 @@ const HelpBlock_1 = tslib_1.__importDefault(require("../../../components/HelpBlo
 const Input_1 = tslib_1.__importDefault(require("../../../components/Input"));
 const rebass_1 = require("rebass");
 const DefaultAdaptableOptions_1 = require("../../../Utilities/Defaults/DefaultAdaptableOptions");
-const ConfigurationForm = (props) => {
-    var _a, _b, _c;
+const AdaptableOptionsForm = (props) => {
+    var _a, _b;
     let abOptions = props.adaptableOptions;
     const layoutOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions), abOptions.layoutOptions);
     const generalOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.generalOptions), abOptions.generalOptions);
     const adaptableQLOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions), abOptions.adaptableQLOptions);
-    const userInterfaceOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions), abOptions.userInterfaceOptions);
-    const searchOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.searchOptions), abOptions.searchOptions);
     const filterOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.filterOptions), abOptions.filterOptions);
-    // we are 'hard-coding' this to use AG Grid but so does helper so ok for now and we can refactor when Adaptable Grid is ready
-    const gridOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.gridOptions), abOptions.gridOptions);
     return (React.createElement(React.Fragment, null,
         React.createElement(HelpBlock_1.default, null, "Base Options"),
         React.createElement(FormLayout_1.default, { margin: 2, columns: [{ name: 'label', style: { textAlign: 'start' } }, { name: 'children' }] },
@@ -36,38 +32,6 @@ const ConfigurationForm = (props) => {
                         abOptions.generalOptions.showMissingPrimaryKeyAlert = showMissingPrimaryKeyWarning;
                         props.onChangeadaptableOptions(abOptions);
                     } }))),
-        React.createElement(HelpBlock_1.default, null, "Grid Options"),
-        React.createElement(FormLayout_1.default, { margin: 2, columns: [{ name: 'children' }, { name: 'label', style: { textAlign: 'start' } }] },
-            React.createElement(FormLayout_1.FormRow, { label: "Enable Range Selection" },
-                React.createElement(CheckBox_1.CheckBox, { checked: gridOptions.enableRangeSelection, onChange: (enableRangeSelection) => {
-                        abOptions = Object.assign({}, abOptions);
-                        abOptions.gridOptions = Object.assign({}, abOptions.gridOptions);
-                        abOptions.gridOptions.enableRangeSelection = enableRangeSelection;
-                        props.onChangeadaptableOptions(abOptions);
-                    } })),
-            React.createElement(FormLayout_1.FormRow, { label: "Show Quick Filter" },
-                React.createElement(CheckBox_1.CheckBox, { checked: (_c = gridOptions.defaultColDef) === null || _c === void 0 ? void 0 : _c.floatingFilter, onChange: (floatingFilter) => {
-                        abOptions = Object.assign({}, abOptions);
-                        abOptions.gridOptions = Object.assign({}, abOptions.gridOptions);
-                        abOptions.gridOptions.defaultColDef = {
-                            floatingFilter,
-                        };
-                        props.onChangeadaptableOptions(abOptions);
-                    } })),
-            React.createElement(FormLayout_1.FormRow, { label: "Suppress Column Virtualisation" },
-                React.createElement(CheckBox_1.CheckBox, { checked: gridOptions.suppressColumnVirtualisation, onChange: (suppressColumnVirtualisation) => {
-                        abOptions = Object.assign({}, abOptions);
-                        abOptions.gridOptions = Object.assign({}, abOptions.gridOptions);
-                        abOptions.gridOptions.suppressColumnVirtualisation = suppressColumnVirtualisation;
-                        props.onChangeadaptableOptions(abOptions);
-                    } })),
-            React.createElement(FormLayout_1.FormRow, { label: "Show Column Menu Button" },
-                React.createElement(CheckBox_1.CheckBox, { checked: gridOptions.suppressMenuHide, onChange: (suppressMenuHide) => {
-                        abOptions = Object.assign({}, abOptions);
-                        abOptions.gridOptions = Object.assign({}, abOptions.gridOptions);
-                        abOptions.gridOptions.suppressMenuHide = suppressMenuHide;
-                        props.onChangeadaptableOptions(abOptions);
-                    } }))),
         React.createElement(HelpBlock_1.default, null, "Layout Options"),
         React.createElement(FormLayout_1.default, { margin: 2, columns: [{ name: 'children' }, { name: 'label', style: { textAlign: 'start' } }] },
             React.createElement(FormLayout_1.FormRow, { label: "Auto Save Layouts" },
@@ -134,4 +98,4 @@ const ConfigurationForm = (props) => {
                         props.onChangeadaptableOptions(abOptions);
                     }, value: filterOptions.maxFilterValuesToDisplay, marginRight: 3 })))));
 };
-exports.default = ConfigurationForm;
+exports.default = AdaptableOptionsForm;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/ConfigurationWizard.js

@@ -7,7 +7,8 @@ const react_1 = require("react");
 const StringExtensions_1 = tslib_1.__importDefault(require("../../../Utilities/Extensions/StringExtensions"));
 const OnePageWizards_1 = require("../../Wizard/OnePageWizards");
 const ConfigurationWizardColumnsStep_1 = require("./ConfigurationWizardColumnsStep");
-const ConfigurationForm_1 = tslib_1.__importDefault(require("./ConfigurationForm"));
+const GridOptionsForm_1 = tslib_1.__importDefault(require("./GridOptionsForm"));
+const AdaptableOptionsForm_1 = tslib_1.__importDefault(require("./AdaptableOptionsForm"));
 const ConfigurationWizard = (props) => {
     const [isPrimaryKeySelected, setIsValid] = React.useState(true);
     const [adaptableOptions, setAdaptableOptions] = react_1.useState(props.adaptableOptions);
@@ -50,7 +51,7 @@ const ConfigurationWizard = (props) => {
     let sections = [
         {
             title: 'Columns',
-            details: 'Configure Adaptable',
+            details: 'Configure Columns',
             isValid: () => {
                 if (!isPrimaryKeySelected) {
                     return 'Primary key column must be included';
@@ -65,10 +66,33 @@ const ConfigurationWizard = (props) => {
             title: 'Adaptable Options',
             details: 'Configure Adaptable Options',
             isValid: () => (adaptableOptions.adaptableId ? true : 'Adaptable ID is required'),
-            render: () => (React.createElement(ConfigurationForm_1.default, { adaptableOptions: adaptableOptions, onChangeadaptableOptions: (abOptions) => {
+            render: () => (React.createElement(AdaptableOptionsForm_1.default, { adaptableOptions: adaptableOptions, onChangeadaptableOptions: (abOptions) => {
                     setAdaptableOptions(abOptions);
                 } })),
         },
+        {
+            title: 'Grid Options',
+            details: 'Configure AG Grid Options',
+            render: () => (React.createElement(GridOptionsForm_1.default, { adaptableOptions: adaptableOptions, onChangeadaptableOptions: (abOptions) => {
+                    setAdaptableOptions(abOptions);
+                } })),
+        },
+        // JW - I would like at some point to do a page of Entitlements
+        // to show all the Modules and let users select which are Full, ReadOnly or Hidden
+        /*
+        {
+          title: 'Entitlements',
+          details: 'Configure Entitlements',
+          render: () => (
+            <EntitlementsForm
+              adaptableOptions={adaptableOptions}
+              onChangeadaptableOptions={(abOptions) => {
+                setAdaptableOptions(abOptions);
+              }}
+            />
+          ),
+        },
+        */
     ];
     if (props.startSections) {
         sections = [

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/{ConfigurationForm.d.ts → EntitlementsForm.d.ts}

@@ -1,8 +1,8 @@
 /// <reference types="react" />
 import { AdaptableOptions } from '../../../types';
-interface ConfigurationFormOptions {
+interface EntitlementsFormOptions {
     adaptableOptions: AdaptableOptions;
     onChangeadaptableOptions: (adaptableOptions: AdaptableOptions) => void;
 }
-declare const ConfigurationForm: (props: ConfigurationFormOptions) => JSX.Element;
-export default ConfigurationForm;
+declare const EntitlementsForm: (props: EntitlementsFormOptions) => JSX.Element;
+export default EntitlementsForm;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/EntitlementsForm.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const FormLayout_1 = tslib_1.__importStar(require("../../../components/FormLayout"));
+const HelpBlock_1 = tslib_1.__importDefault(require("../../../components/HelpBlock"));
+const DefaultAdaptableOptions_1 = require("../../../Utilities/Defaults/DefaultAdaptableOptions");
+const EntitlementsForm = (props) => {
+    let abOptions = props.adaptableOptions;
+    const entitlementOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.entitlementOptions), abOptions.entitlementOptions);
+    const gridOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.gridOptions), abOptions.gridOptions);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(HelpBlock_1.default, null, "EntitlementOptions Options"),
+        React.createElement(FormLayout_1.default, { margin: 2, columns: [{ name: 'children' }, { name: 'label', style: { textAlign: 'start' } }] },
+            React.createElement(FormLayout_1.FormRow, { label: "Entitlements to be set here" }))));
+};
+exports.default = EntitlementsForm;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/GridOptionsForm.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { AdaptableOptions } from '../../../types';
+interface GridOptionsFormOptions {
+    adaptableOptions: AdaptableOptions;
+    onChangeadaptableOptions: (adaptableOptions: AdaptableOptions) => void;
+}
+declare const GridOptionsForm: (props: GridOptionsFormOptions) => JSX.Element;
+export default GridOptionsForm;