@adaptabletools/adaptable 11.1.4 → 11.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "11.1.4",
+  "version": "11.1.5",
   "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: 1649274832417;
+declare const _default: 1649336531486;
 export default _default;

package/publishTimestamp.js

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

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

@@ -33,6 +33,7 @@ import { AlertButtonForm, AlertDefinition } from '../../PredefinedConfig/AlertSt
 import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
 import { AdaptableFrameworkComponent } from '../../AdaptableOptions/AdaptableFrameworkComponent';
 import { IMetamodelService } from '../../Utilities/Services/Interface/IMetamodelService';
+import { IModuleCollection } from '../../Strategy/Interface/IModule';
 export declare class InternalApiImpl extends ApiBase implements InternalApi {
     getSystemState(): SystemState;
     getAdaptableFormFromAlertForm(alertForm: string | AlertButtonForm, context: any, defaultMessageType?: AdaptableMessageType): (Omit<AdaptableForm<AlertButtonContext>, 'buttons'> & {
@@ -95,8 +96,11 @@ export declare class InternalApiImpl extends ApiBase implements InternalApi {
     getAlertService(): IAlertService;
     getTeamSharingService(): ITeamSharingService;
     getMetamodelService(): IMetamodelService;
+    getModules(): IModuleCollection;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
     runModuleInAdaptableQL(adaptableQLModule: AdaptableQLModule): boolean;
+    forAllRowNodesDo(func: (rowNode: RowNode) => void): void;
+    forAllVisibleRowNodesDo(func: (rowNode: RowNode) => void): void;
     buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
     clearFlashingCellState(): void;
     clearUpdatedRowState(): void;

package/src/Api/Implementation/InternalApiImpl.js

@@ -270,6 +270,9 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
     getMetamodelService() {
         return this.adaptable.MetamodelService;
     }
+    getModules() {
+        return this.adaptable.adaptableModules;
+    }
     getModuleFriendlyName(adaptableModule) {
         var _a, _b;
         return ((_b = (_a = this.adaptable.ModuleService.getModuleInfoByModule(adaptableModule)) === null || _a === void 0 ? void 0 : _a.FriendlyName) !== null && _b !== void 0 ? _b : adaptableModule);
@@ -278,6 +281,12 @@ class InternalApiImpl extends ApiBase_1.ApiBase {
         const adaptableQLModules = this.getAdaptableQLOptions().externallyEvaluatedModules;
         return !adaptableQLModules.includes(adaptableQLModule);
     }
+    forAllRowNodesDo(func) {
+        this.adaptable.forAllRowNodesDo(func);
+    }
+    forAllVisibleRowNodesDo(func) {
+        this.adaptable.forAllVisibleRowNodesDo(func);
+    }
     buildStandaloneColumnHeader(column) {
         return this.adaptable.buildStandaloneColumnHeader(column);
     }

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

@@ -14,4 +14,5 @@ export declare class ThemeApiImpl extends ApiBase implements ThemeApi {
     getAllUserTheme(): AdaptableTheme[];
     getAllTheme(): AdaptableTheme[];
     showThemePopup(): void;
+    getAgGridCurrentThemeName(): string;
 }

package/src/Api/Implementation/ThemeApiImpl.js

@@ -62,5 +62,8 @@ class ThemeApiImpl extends ApiBase_1.ApiBase {
     showThemePopup() {
         this.showModulePopup(ModuleConstants.ThemeModuleId);
     }
+    getAgGridCurrentThemeName() {
+        return this.adaptable.getAgGridCurrentThemeName();
+    }
 }
 exports.ThemeApiImpl = ThemeApiImpl;

package/src/Api/InternalApi.d.ts

@@ -32,6 +32,7 @@ import { AlertButtonForm } from '../PredefinedConfig/AlertState';
 import { AdaptableFrameworkComponent } from '../AdaptableOptions/AdaptableFrameworkComponent';
 import { IMetamodelService } from '../Utilities/Services/Interface/IMetamodelService';
 import { RowNode } from '@ag-grid-community/all-modules';
+import { IModuleCollection } from '../Strategy/Interface/IModule';
 /**
  * This set of api methods is designed for **internal use of Adaptable** only.
  *
@@ -99,8 +100,11 @@ export interface InternalApi {
     getAlertService(): IAlertService;
     getTeamSharingService(): ITeamSharingService;
     getMetamodelService(): IMetamodelService;
+    getModules(): IModuleCollection;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;
     runModuleInAdaptableQL(adaptableQLModule: AdaptableQLModule): boolean;
+    forAllRowNodesDo(func: (rowNode: RowNode) => void): void;
+    forAllVisibleRowNodesDo(func: (rowNode: RowNode) => void): void;
     buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
     getCustomSortComparer(column: AdaptableColumn): ColumnValuesComparer | undefined;
     clearFlashingCellState(): void;

package/src/Api/ThemeApi.d.ts

@@ -56,4 +56,8 @@ export interface ThemeApi {
      * Opens Settings Panel with Theme section selected and visible
      */
     showThemePopup(): void;
+    /**
+     * Get the name of the current AG Grid theme
+     */
+    getAgGridCurrentThemeName(): string;
 }

package/src/Strategy/AlertModule.js

@@ -156,9 +156,7 @@ class AlertModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         var _a;
         // the row node data is most probably stale because the reactive queries buffer the changed data
         // so we have to refresh it
-        reactiveAlertInfo.dataChangeLogEntry.rowNode = this.api.internalApi
-            .getAdaptableInstance()
-            .getRowNodeForPrimaryKey(reactiveAlertInfo.dataChangeLogEntry.primaryKeyValue);
+        reactiveAlertInfo.dataChangeLogEntry.rowNode = this.api.gridApi.getRowNodeForPrimaryKey(reactiveAlertInfo.dataChangeLogEntry.primaryKeyValue);
         reactiveAlertInfo.dataChangeLogEntry.rowData = (_a = reactiveAlertInfo.dataChangeLogEntry.rowNode) === null || _a === void 0 ? void 0 : _a.data;
         if (reactiveAlertInfo.type === 'alert') {
             this.showAlertForDefinitions(reactiveAlertInfo.dataChangeLogEntry, [

package/src/Strategy/CalculatedColumnModule.js

@@ -77,7 +77,7 @@ class CalculatedColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 values: [calculateColumn.FriendlyName],
             },
             getExpressionViewItems_1.getExpressionViewItems(calculateColumn.Query),
-        ];
+        ].filter(Boolean);
         if (ArrayExtensions_1.default.IsNotNullOrEmpty(settingsTags)) {
             items.push({
                 name: 'Settings',

package/src/Strategy/Utilities/getExportColumnsViewItems.js

@@ -4,6 +4,6 @@ exports.getExportColumnsViewItems = void 0;
 exports.getExportColumnsViewItems = (report, api) => {
     return {
         name: 'Columns',
-        values: [api.internalApi.getReportService().GetReportColumnScopeShortDescription(report)],
+        values: [...api.internalApi.getReportService().GetReportColumnScopeShortDescription(report)],
     };
 };

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -195,7 +195,7 @@ const getSumAggregation$ = (source$, initialSum) => {
 };
 const getColumnValueSum = (column, context) => {
     let sum = 0;
-    context.api.internalApi.getAdaptableInstance().forAllRowNodesDo((rowNode) => {
+    context.api.internalApi.forAllRowNodesDo((rowNode) => {
         var _a;
         // if there is a WHERE clause defined, check if the current rowNode satisfies the condition
         if (context.filterFn && !context.filterFn(rowNode)) {

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -233,7 +233,7 @@ const getDataChangedInfoStub = (context) => {
     }
     else {
         // if there is a WHERE clause defined, find the first rowNode which satisfies the condition
-        context.api.internalApi.getAdaptableInstance().forAllRowNodesDo((rowNode) => {
+        context.api.internalApi.forAllRowNodesDo((rowNode) => {
             if (!rowNodeStub) {
                 if (context.filterFn(rowNode)) {
                     rowNodeStub = rowNode;

package/src/Utilities/Services/AlertService.d.ts

@@ -1,12 +1,12 @@
 import { IAlertService } from './Interface/IAlertService';
 import { AlertDefinition } from '../../PredefinedConfig/AlertState';
 import { EmitterCallback } from '../Emitter';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableApi } from '../../types';
 export declare class AlertService implements IAlertService {
-    private adaptable;
+    private adaptableApi;
     private emitter;
     private reactiveAlertsMap;
-    constructor(adaptable: IAdaptable);
+    constructor(adaptableApi: AdaptableApi);
     onReactiveAlertTriggered: (callback: EmitterCallback) => (() => void);
     createReactiveAlert(alertDefinition: AlertDefinition): void;
     deleteReactiveAlert(alertDefinition: AlertDefinition): void;

package/src/Utilities/Services/AlertService.js

@@ -7,8 +7,8 @@ const rxjs_1 = require("rxjs");
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
 class AlertService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
         this.reactiveAlertsMap = new Map();
         this.onReactiveAlertTriggered = (callback) => {
             return this.emitter.on('ReactiveAlertTriggered', callback);
@@ -58,17 +58,17 @@ class AlertService {
     }
     isValidExpression(rule) {
         return rule.ObservableExpression
-            ? this.adaptable.api.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)
+            ? this.adaptableApi.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)
             : rule.AggregatedBooleanExpression
-                ? this.adaptable.api.queryLanguageApi.isValidAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
+                ? this.adaptableApi.queryLanguageApi.isValidAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
                 : false;
     }
     evaluateReactiveExpression(rule) {
         return rule.ObservableExpression
-            ? this.adaptable.api.internalApi
+            ? this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .evaluateObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId)
-            : this.adaptable.api.internalApi
+            : this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .evaluateAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
     }

package/src/Utilities/Services/CalculatedColumnExpressionService.d.ts

@@ -1,11 +1,11 @@
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ICalculatedColumnExpressionService } from './Interface/ICalculatedColumnExpressionService';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableCalculatedColumnQuery, CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
+import { AdaptableApi } from '../../../types';
 export declare class CalculatedColumnExpressionService implements ICalculatedColumnExpressionService {
-    private adaptable;
+    private adaptableApi;
     private aggregatedScalarCalculatedColumnsMap;
-    constructor(adaptable: IAdaptable);
+    constructor(adaptableApi: AdaptableApi);
     getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
     isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
     evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, node: RowNode): any;

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -6,11 +6,11 @@ const LoggingHelper_1 = require("../Helpers/LoggingHelper");
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
 const scalarAggregationHelper_1 = require("../ExpressionFunctions/scalarAggregationHelper");
 class CalculatedColumnExpressionService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
         this.aggregatedScalarCalculatedColumnsMap = new Map();
-        this.adaptable = adaptable;
-        this.adaptable.api.internalApi
+        this.adaptableApi = adaptableApi;
+        this.adaptableApi.internalApi
             .getDataService()
             .on('CellDataChanged', (cellDataChangedInfo) => {
             if (cellDataChangedInfo.trigger === 'aggChange') {
@@ -27,7 +27,7 @@ class CalculatedColumnExpressionService {
                 }
             });
             if (refreshedCalculatedColumns.length) {
-                this.adaptable.api.gridApi.refreshCells(null, refreshedCalculatedColumns);
+                this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
             }
         });
     }
@@ -39,8 +39,8 @@ class CalculatedColumnExpressionService {
                 // we definitely don't want to aggregate everything only to get the data type
                 return Enums_1.DataType.Number;
             }
-            let firstRowNode = this.adaptable.api.gridApi.getFirstRowNode();
-            let firstRowValue = this.adaptable.api.internalApi
+            let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
+            let firstRowValue = this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
             if (firstRowValue instanceof Date) {
@@ -57,7 +57,7 @@ class CalculatedColumnExpressionService {
             }
         }
         catch (e) {
-            LoggingHelper_1.LogAdaptableWarning(`Invalid CalculatedColumn expression ${this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumnQuery)} :: ${e}`);
+            LoggingHelper_1.LogAdaptableWarning(`Invalid CalculatedColumn expression ${this.adaptableApi.queryLanguageApi.getAdaptableQueryExpression(calculatedColumnQuery)} :: ${e}`);
             return Enums_1.DataType.Number;
         }
     }
@@ -65,8 +65,8 @@ class CalculatedColumnExpressionService {
         if (calculatedColumnQuery.ScalarExpression) {
             try {
                 // TODO AFL add a cached validation for ScalarExpression, just like for all the other types
-                let firstRowNode = this.adaptable.getFirstRowNode();
-                this.adaptable.api.internalApi
+                let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
+                this.adaptableApi.internalApi
                     .getQueryLanguageService()
                     .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
                 return true;
@@ -77,7 +77,7 @@ class CalculatedColumnExpressionService {
             }
         }
         if (calculatedColumnQuery.AggregatedScalarExpression) {
-            const validationResult = this.adaptable.api.internalApi
+            const validationResult = this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .validateAggregatedScalar(calculatedColumnQuery.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
             return validationResult.isValid;
@@ -88,12 +88,12 @@ class CalculatedColumnExpressionService {
     evaluateCalculatedColumnQuery(calculatedColumn, node) {
         var _a, _b, _c, _d, _e;
         try {
-            if (this.adaptable.api.gridApi.isGroupRowNode(node)) {
+            if (this.adaptableApi.gridApi.isGroupRowNode(node)) {
                 return undefined;
             }
             // no validation here, this function has to be as performant as possible
             if ((_a = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression) {
-                return this.adaptable.api.internalApi
+                return this.adaptableApi.internalApi
                     .getQueryLanguageService()
                     .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, node);
             }
@@ -112,10 +112,10 @@ 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.adaptable.api.internalApi
+            const aggregationConfig = this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
-            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(aggregationConfig.value, calculatedColumn, this.adaptable);
+            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(aggregationConfig.value, calculatedColumn, this.adaptableApi);
             this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
         }
     }
@@ -128,10 +128,10 @@ class CalculatedColumnExpressionService {
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
 class AggregatedScalarCalculatedColumn {
-    constructor(expressionEvaluation, calculatedColumn, adaptable) {
+    constructor(expressionEvaluation, calculatedColumn, adaptableApi) {
         this.expressionEvaluation = expressionEvaluation;
         this.calculatedColumn = calculatedColumn;
-        this.adaptable = adaptable;
+        this.adaptableApi = adaptableApi;
         this.aggregationResult = this.computeAggregatedValue(expressionEvaluation);
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(expressionEvaluation.aggregationParams.reducers)[0];
@@ -153,7 +153,7 @@ class AggregatedScalarCalculatedColumn {
         return this.expressionEvaluation.columnDependencies;
     }
     computeAggregatedValue(expressionEvaluation) {
-        const gridData = this.adaptable.api.gridApi.getGridData();
+        const gridData = this.adaptableApi.gridApi.getGridData();
         if (!expressionEvaluation.cumulateOver) {
             return scalarAggregationHelper_1.aggregate(expressionEvaluation.aggregationParams, gridData);
         }
@@ -174,7 +174,7 @@ class AggregatedScalarCalculatedColumn {
             if (!expressionEvaluation.aggregationParams.groupBy) {
                 expressionEvaluation.aggregationParams.groupBy = [];
             }
-            const gridPrimaryKey = this.adaptable.adaptableOptions.primaryKey;
+            const gridPrimaryKey = this.adaptableApi.internalApi.getAdaptableOptions().primaryKey;
             // !! aggregationParams mutated
             expressionEvaluation.aggregationParams.groupBy.push({ field: gridPrimaryKey });
             // 3. cumulate
@@ -185,7 +185,7 @@ class AggregatedScalarCalculatedColumn {
         var _a, _b;
         if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
             const groupColumns = this.expressionEvaluation.aggregationParams.groupBy.map((groupByParam) => groupByParam.field);
-            const groupKeys = groupColumns.map((groupColumnName) => this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, groupColumnName));
+            const groupKeys = groupColumns.map((groupColumnName) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, groupColumnName));
             return (_b = this.aggregationResult.deepMap.get(groupKeys)) === null || _b === void 0 ? void 0 : _b.reducerResults[this.aggregationReducerName];
         }
         return this.aggregationResult.reducerResults[this.aggregationReducerName];

package/src/Utilities/Services/EntitlementService.d.ts

@@ -1,10 +1,10 @@
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { IEntitlementService } from './Interface/IEntitlementService';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { AccessLevel } from '../../PredefinedConfig/Common/Entitlement';
+import { AdaptableApi } from '../../../types';
 export declare class EntitlementService implements IEntitlementService {
-    private adaptable;
-    constructor(adaptable: IAdaptable);
+    private adaptableApi;
+    constructor(adaptableApi: AdaptableApi);
     setModulesEntitlements(): void;
     isModuleHiddenEntitlement(adaptableModule: AdaptableModule): boolean;
     isModuleFullEntitlement(adaptableModule: AdaptableModule): boolean;

package/src/Utilities/Services/EntitlementService.js

@@ -2,12 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntitlementService = void 0;
 class EntitlementService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
+        this.adaptableApi = adaptableApi;
     }
     setModulesEntitlements() {
-        this.adaptable.adaptableModules.forEach((module) => {
+        this.adaptableApi.internalApi
+            .getModuleService()
+            .getModuleCollection()
+            .forEach((module) => {
             module.setModuleEntitlement();
         });
     }
@@ -21,15 +24,16 @@ class EntitlementService {
         return this.getEntitlementAccessLevelForModule(adaptableModule) == 'ReadOnly';
     }
     getEntitlementAccessLevelForModule(adaptableModule) {
-        let entitlementOptions = this.adaptable.adaptableOptions.entitlementOptions;
+        let adaptableOptions = this.adaptableApi.internalApi.getAdaptableOptions();
+        let entitlementOptions = adaptableOptions.entitlementOptions;
         if (entitlementOptions) {
             const defaultAccessLevel = typeof entitlementOptions.defaultAccessLevel === 'function'
-                ? entitlementOptions.defaultAccessLevel(this.adaptable.adaptableOptions.userName, this.adaptable.adaptableOptions.adaptableId)
+                ? entitlementOptions.defaultAccessLevel(adaptableOptions.userName, adaptableOptions.adaptableId)
                 : entitlementOptions.defaultAccessLevel;
             const moduleEntitlements = entitlementOptions.moduleEntitlements;
             if (moduleEntitlements) {
                 if (typeof moduleEntitlements === 'function') {
-                    const dynamicModuleEntitlement = moduleEntitlements(adaptableModule, this.adaptable.adaptableOptions.userName, this.adaptable.adaptableOptions.adaptableId, defaultAccessLevel);
+                    const dynamicModuleEntitlement = moduleEntitlements(adaptableModule, adaptableOptions.userName, adaptableOptions.adaptableId, defaultAccessLevel);
                     return dynamicModuleEntitlement !== null && dynamicModuleEntitlement !== void 0 ? dynamicModuleEntitlement : defaultAccessLevel;
                 }
                 else {
@@ -48,7 +52,7 @@ class EntitlementService {
         if (this.isModuleHiddenEntitlement('GridInfo')) {
             return false;
         }
-        return this.adaptable.api.internalApi
+        return this.adaptableApi.internalApi
             .getAdaptableOptions()
             .userInterfaceOptions.gridInfoSections.includes(section);
     }

package/src/Utilities/Services/Interface/IReportService.d.ts

@@ -8,7 +8,7 @@ export interface IReportService extends IAdaptableService {
     IsSystemReport(reportName: string): boolean;
     IsSystemReportActive(reportName: SystemReportName): boolean;
     IsSystemExportDestinationActive(exportDestination: SystemExportDestination): boolean;
-    GetReportColumnScopeShortDescription(report: Report): string;
+    GetReportColumnScopeShortDescription(report: Report): string[];
     GetReportColumnScopeLongDescription(report: Report): string;
     GetReportExpressionDescription(Report: Report, cols: AdaptableColumn[]): string;
     GetReportColumnsForReport(report: Report): AdaptableColumn[];

package/src/Utilities/Services/MetamodelService.d.ts

@@ -1,9 +1,9 @@
 import { GridInfoOptions, IMetamodelService } from './Interface/IMetamodelService';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AdaptableApi } from '../../../types';
 export declare class MetamodelService implements IMetamodelService {
-    private adaptable;
+    private adaptableApi;
     private gridInfoOptions;
-    constructor(adaptable: IAdaptable);
+    constructor(adaptableApi: AdaptableApi);
     getGridInfoOptions(): GridInfoOptions;
     private buildGridInfoOptions;
     private mapGridInfoContainerItems;

package/src/Utilities/Services/MetamodelService.js

@@ -4,10 +4,10 @@ exports.MetamodelService = void 0;
 const adaptable_metamodel_1 = require("../../metamodel/adaptable.metamodel");
 const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
 class MetamodelService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
         this.gridInfoOptions = new Map();
-        this.adaptable = adaptable;
+        this.adaptableApi = adaptableApi;
         this.gridInfoOptions = this.buildGridInfoOptions();
     }
     getGridInfoOptions() {
@@ -17,7 +17,7 @@ class MetamodelService {
         const gridInfoOptions = new Map();
         const adaptableMetamodel = adaptable_metamodel_1.ADAPTABLE_METAMODEL;
         const adaptableOptionsMetamodel = adaptableMetamodel['AdaptableOptions'];
-        const adaptableOptionsValues = this.adaptable.adaptableOptions;
+        const adaptableOptionsValues = this.adaptableApi.internalApi.getAdaptableOptions();
         const adaptableOptionsDefaultValues = DefaultAdaptableOptions_1.DefaultAdaptableOptions;
         if (!adaptableOptionsMetamodel) {
             // should never happen

package/src/Utilities/Services/ModuleService.d.ts

@@ -1,12 +1,12 @@
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableModule } from '../../types';
 import { IModule, ModuleInfo, IModuleCollection } from '../../Strategy/Interface/IModule';
 import { TeamSharingImportInfo } from '../../PredefinedConfig/TeamSharingState';
 import { AdaptableObject } from '../../PredefinedConfig/Common/AdaptableObject';
 import { IModuleService } from './Interface/IModuleService';
+import { AdaptableApi } from '../../../types';
 export declare class ModuleService implements IModuleService {
-    private adaptable;
-    constructor(adaptable: IAdaptable);
+    private adaptableApi;
+    constructor(adaptableApi: AdaptableApi);
     createModuleMenus(): void;
     isModuleAvailable(adaptableModule: AdaptableModule): boolean;
     isModuleEditable(adaptableModule: AdaptableModule): boolean;

package/src/Utilities/Services/ModuleService.js

@@ -5,14 +5,14 @@ const tslib_1 = require("tslib");
 const Helper_1 = tslib_1.__importDefault(require("../Helpers/Helper"));
 const DocumentationLinkConstants_1 = require("../Constants/DocumentationLinkConstants");
 class ModuleService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
+        this.adaptableApi = adaptableApi;
     }
     createModuleMenus() {
         const dropdownMenuItems = [];
         const buttonMenuItems = [];
-        this.adaptable.adaptableModules.forEach((module) => {
+        this.getModuleCollection().forEach((module) => {
             const dropdownMenuItem = module.addModuleMenuItem('ModuleMenu');
             if (Helper_1.default.objectExists(dropdownMenuItem)) {
                 if (dropdownMenuItems.findIndex((m) => m.module == dropdownMenuItem.module) == -1) {
@@ -27,39 +27,39 @@ class ModuleService {
             }
         });
         // store the main menu as we will re-use (and it never changes)
-        this.adaptable.api.internalApi.setModuleDropdownMenuItems(dropdownMenuItems);
-        this.adaptable.api.internalApi.setModuleButtonMenuItems(buttonMenuItems);
+        this.adaptableApi.internalApi.setModuleDropdownMenuItems(dropdownMenuItems);
+        this.adaptableApi.internalApi.setModuleButtonMenuItems(buttonMenuItems);
     }
     isModuleAvailable(adaptableModule) {
-        let module = this.adaptable.adaptableModules.get(adaptableModule);
+        let module = this.getModuleCollection().get(adaptableModule);
         if (!module) {
             return false;
         }
         return module.isModuleAvailable();
     }
     isModuleEditable(adaptableModule) {
-        let module = this.adaptable.adaptableModules.get(adaptableModule);
+        let module = this.getModuleCollection().get(adaptableModule);
         if (!module) {
             return false;
         }
         return module.isModuleEditable();
     }
     getTeamSharingAction(adaptableModule) {
-        let module = this.adaptable.adaptableModules.get(adaptableModule);
+        let module = this.getModuleCollection().get(adaptableModule);
         if (!module) {
             return undefined;
         }
         return module.getTeamSharingAction();
     }
     getModuleById(adaptableModule) {
-        return this.adaptable.adaptableModules.get(adaptableModule);
+        return this.getModuleCollection().get(adaptableModule);
     }
     getModuleInfoByModule(adaptableModule) {
         const module = this.getModuleById(adaptableModule);
         return module ? module.moduleInfo : undefined;
     }
     getModuleInfoByFriendlyName(friendlyName) {
-        for (let module of this.adaptable.adaptableModules.values()) {
+        for (let module of this.getModuleCollection().values()) {
             let moduleInfo = module.moduleInfo;
             if (moduleInfo && moduleInfo.FriendlyName == friendlyName) {
                 return moduleInfo;
@@ -72,7 +72,7 @@ class ModuleService {
         return (_a = this.getModuleById(adaptableModule)) === null || _a === void 0 ? void 0 : _a.getPopupMaxWidth();
     }
     getModuleCollection() {
-        return this.adaptable.adaptableModules;
+        return this.adaptableApi.internalApi.getModules();
     }
     getModuleDocumentationPageByModule(adaptableModule) {
         let url = `${DocumentationLinkConstants_1.HOST_URL_DOCS}/`;

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -1,19 +1,19 @@
 import { IQueryLanguageService } from './Interface/IQueryLanguageService';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { Observable } from 'rxjs';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
 import { AggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import { AdaptableApi } from '../../../types';
 export declare class QueryLanguageService implements IQueryLanguageService {
-    private adaptable;
+    private adaptableApi;
     private cacheBooleanValidation;
     private cacheObservableValidation;
     private cacheAggregatedBooleanValidation;
     private cacheAggregatedScalarValidation;
     private cacheModuleSpecificExpressionFunctions;
-    constructor(adaptable: IAdaptable);
+    constructor(adaptableApi: AdaptableApi);
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;