@adaptabletools/adaptable 11.1.2 → 11.1.5

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;

package/src/Utilities/Services/QueryLanguageService.js

@@ -6,8 +6,8 @@ const parser = tslib_1.__importStar(require("../../parser/src"));
 const rxjs_1 = require("rxjs");
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
 class QueryLanguageService {
-    constructor(adaptable) {
-        this.adaptable = adaptable;
+    constructor(adaptableApi) {
+        this.adaptableApi = adaptableApi;
         this.cacheBooleanValidation = new Map();
         this.cacheObservableValidation = new Map();
         this.cacheAggregatedBooleanValidation = new Map();
@@ -19,7 +19,7 @@ class QueryLanguageService {
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         return parser.evaluate(expression, {
             node: rowNode,
-            api: this.adaptable.api,
+            api: this.adaptableApi,
             functions: booleanAndScalarFunctions,
         });
     }
@@ -31,7 +31,7 @@ class QueryLanguageService {
         const aggregatedScalarFunctions = this.getModuleExpressionFunctions(module).aggregatedScalarFunctions;
         return parser.evaluate(expression, {
             node: null,
-            api: this.adaptable.api,
+            api: this.adaptableApi,
             functions: aggregatedScalarFunctions,
         });
     }
@@ -40,7 +40,7 @@ class QueryLanguageService {
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const reactiveExpression$ = parser.evaluate(reactiveExpression, {
             node: reactiveExpression,
-            api: this.adaptable.api,
+            api: this.adaptableApi,
             functions: moduleExpressionFunctions.observableFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
         });
@@ -51,7 +51,7 @@ class QueryLanguageService {
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const aggregationExpression$ = parser.evaluate(aggregationExpression, {
             node: aggregationExpression,
-            api: this.adaptable.api,
+            api: this.adaptableApi,
             functions: moduleExpressionFunctions.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
         });
@@ -75,7 +75,7 @@ class QueryLanguageService {
             }
             const force = (_a = config === null || config === void 0 ? void 0 : config.force) !== null && _a !== void 0 ? _a : false;
             // get searchOptions to see if validation should be performed
-            if (!this.adaptable.api.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
+            if (!this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .performExpressionValidation &&
                 !force) {
                 const result = { isValid: true, errorMessage: '' };
@@ -103,7 +103,7 @@ class QueryLanguageService {
                 return result;
             }
             // evaluating the expression is the only way to catch circular named query references
-            let firstRowNode = this.adaptable.getFirstRowNode();
+            let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
             this.evaluateBooleanExpression(expression, module, firstRowNode);
             const result = {
                 isValid: true,
@@ -243,15 +243,15 @@ class QueryLanguageService {
         if (!module) {
             LoggingHelper_1.LogAdaptableInfo(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
-                booleanFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                booleanFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                     .defaultBooleanFunctions,
-                scalarFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                scalarFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                     .defaultScalarFunctions,
-                observableFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                observableFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                     .defaultObservableFunctions,
-                aggregatedBooleanFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                aggregatedBooleanFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                     .defaultAggregatedBooleanFunctions,
-                aggregatedScalarFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                aggregatedScalarFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                     .defaultAggregatedScalarFunctions,
             };
         }
@@ -259,17 +259,18 @@ class QueryLanguageService {
         if (cachedResult) {
             return cachedResult;
         }
-        const moduleSpecificOptions = (_b = (_a = this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+        const moduleSpecificOptions = (_b = (_a = this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
             .moduleExpressionFunctions) === null || _a === void 0 ? void 0 : _a[module]) !== null && _b !== void 0 ? _b : {};
         const moduleSpecificFunctions = {
-            booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+            booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .defaultBooleanFunctions,
-            scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions.defaultScalarFunctions,
-            observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+            scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
+                .defaultScalarFunctions,
+            observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .defaultObservableFunctions,
-            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .defaultAggregatedBooleanFunctions,
-            aggregatedScalarFunctions: (_g = moduleSpecificOptions.aggregatedScalarFunctions) !== null && _g !== void 0 ? _g : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+            aggregatedScalarFunctions: (_g = moduleSpecificOptions.aggregatedScalarFunctions) !== null && _g !== void 0 ? _g : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .defaultAggregatedScalarFunctions,
         };
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleSpecificFunctions);

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

@@ -1,17 +1,17 @@
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { Report, ReportData, SystemReportName } from '../../PredefinedConfig/ExportState';
 import { IReportService } from './Interface/IReportService';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { SystemExportDestination } from '../../AdaptableOptions/ExportOptions';
+import { AdaptableApi } from '../../../types';
 export declare class ReportService implements IReportService {
-    private adaptable;
-    constructor(adaptable: IAdaptable);
+    private adaptableApi;
+    constructor(adaptableApi: AdaptableApi);
     CreateSystemReport(systemReportName: SystemReportName): Report;
     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, includePrimaryKey?: boolean): AdaptableColumn[];