@adaptabletools/adaptable 19.1.0 → 19.1.1

package/src/Api/Implementation/ColumnFilterApiImpl.js

@@ -4,9 +4,9 @@ import { ApiBase } from './ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { ColumnFilterInternalApi } from '../Internal/ColumnFilterInternalApi';
 export class ColumnFilterApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ColumnFilterInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ColumnFilterInternalApi(_adaptable);
     }
     getFilterPredicateDefsForColumn(column) {
         const scope = {
@@ -27,11 +27,11 @@ export class ColumnFilterApiImpl extends ApiBase {
         this.dispatchAction(SystemRedux.SystemQuickFilterBarHide());
     }
     isQuickFilterAvailable() {
-        return this.adaptable.isQuickFilterAvailable();
+        return this._adaptable.isQuickFilterAvailable();
     }
     isQuickFilterVisible() {
         return (this.isQuickFilterAvailable() &&
-            this.getAdaptableApi().internalApi.getSystemState().IsQuickFilterVisible);
+            this.getAdaptableInternalApi().getSystemState().IsQuickFilterVisible);
     }
     getColumnFilters() {
         var _a;
@@ -91,7 +91,7 @@ export class ColumnFilterApiImpl extends ApiBase {
     }
     clearColumnFilters() {
         this.dispatchAction(LayoutRedux.LayoutColumnFilterClearAll());
-        this.adaptable.clearColumnFiltering();
+        this._adaptable.clearColumnFiltering();
     }
     clearAndSetColumnFilters(columnFilters) {
         this.clearColumnFilters();
@@ -166,7 +166,7 @@ export class ColumnFilterApiImpl extends ApiBase {
         let columnFilterForColumn = this.getColumnFilterForColumn(columnId);
         if (columnFilterForColumn) {
             this.dispatchAction(LayoutRedux.LayoutColumnFilterClear(columnFilterForColumn));
-            this.adaptable.clearColumnFilteringForColumns([columnId]);
+            this._adaptable.clearColumnFilteringForColumns([columnId]);
         }
     }
 }

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

@@ -1,8 +1,6 @@
 import { ColumnMenuApi } from '../ColumnMenuApi';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ApiBase } from './ApiBase';
 export declare class ColumnMenuApiImpl extends ApiBase implements ColumnMenuApi {
-    constructor(adaptable: IAdaptable);
     showColumnMenu(columnKey: string): void;
     hideColumnMenu(): void;
 }

package/src/Api/Implementation/ColumnMenuApiImpl.js

@@ -1,12 +1,9 @@
 import { ApiBase } from './ApiBase';
 export class ColumnMenuApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-    }
     showColumnMenu(columnKey) {
-        this.adaptable.agGridAdapter.getAgGridApi().showColumnMenu(columnKey);
+        this.getAgGridApi().showColumnMenu(columnKey);
     }
     hideColumnMenu() {
-        this.adaptable.agGridAdapter.getAgGridApi().hidePopupMenu();
+        this.getAgGridApi().hidePopupMenu();
     }
 }

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

@@ -5,7 +5,7 @@ import { CommentsInternalApi } from '../Internal/CommentsInternalApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 export declare class CommentsApiImpl extends ApiBase implements CommentApi {
     internalApi: CommentsInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getCommentThread(address: CellAddress): CommentThread | undefined;
     getGridComments(): CommentThread[];
     editComment(comment: AdaptableComment, address: CellAddress): void;

package/src/Api/Implementation/CommentsApiImpl.js

@@ -3,10 +3,11 @@ import { ApiBase } from './ApiBase';
 import ObjectFactory from '../../Utilities/ObjectFactory';
 import AdaptableHelper from '../../Utilities/Helpers/AdaptableHelper';
 import { CommentsInternalApi } from '../Internal/CommentsInternalApi';
+import _ from 'lodash';
 export class CommentsApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new CommentsInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new CommentsInternalApi(_adaptable);
     }
     getCommentThread(address) {
         return CommentRedux.GetCellCommentSelector(this.getAdaptableState().Comment, address);
@@ -14,6 +15,7 @@ export class CommentsApiImpl extends ApiBase {
     getGridComments() {
         var _a;
         return (_a = this.getAdaptableState().Comment.CommentThreads) !== null && _a !== void 0 ? _a : [];
+        _;
     }
     editComment(comment, address) {
         this.dispatchAction(CommentRedux.CommentsEdit({ comment, cellAddress: address }));
@@ -45,6 +47,6 @@ export class CommentsApiImpl extends ApiBase {
         this.setGridComments([]);
     }
     hideCommentsPopup() {
-        this.adaptable.api.internalApi.getCellPopupService().hidePopup();
+        this.getAdaptableInternalApi().getCellPopupService().hidePopup();
     }
 }

package/src/Api/Implementation/ConfigApiImpl.js

@@ -39,21 +39,21 @@ export class ConfigApiImpl extends ApiBase {
         Helper.copyToClipboard(stringifiedState);
     }
     getPredefinedConfig() {
-        return this.adaptable.adaptableOptions.predefinedConfig;
+        return this.getPredefinedConfig;
     }
     reloadPredefinedConfig(newPredefinedConfig) {
         var _a;
-        const adaptableOptions = this.adaptable.adaptableOptions;
+        const adaptableOptions = this.getOptions();
         const oldState = this.getPersistedState();
         // clearing filters so that AG Grid doesnt display the filter icon in a column header after grid reloads
         // but this is a hack so would be nicer if there was a better way to do this
-        this.getAdaptableApi().gridApi.clearGridFiltering();
+        this.getGridApi().clearGridFiltering();
         const clearStateFn = ((_a = adaptableOptions.stateOptions) === null || _a === void 0 ? void 0 : _a.clearState) ||
             (() => {
                 localStorage.removeItem(adaptableOptions.adaptableStateKey);
                 return Promise.resolve(true);
             });
-        this.adaptable.adaptableStore.saveStateNow(this.adaptable).then(() => {
+        this.getAdaptableSore().saveStateNow(this._adaptable).then(() => {
             const promise = clearStateFn({
                 adaptableId: adaptableOptions.adaptableId,
                 adaptableStateKey: adaptableOptions.adaptableStateKey,
@@ -66,7 +66,7 @@ export class ConfigApiImpl extends ApiBase {
                 }).then(() => {
                     const newState = this.getPersistedState();
                     const stateReloadedInfo = Object.assign({ oldState,
-                        newState, adaptableStateKey: adaptableOptions.adaptableStateKey }, this.getAdaptableApi().internalApi.buildBaseContext());
+                        newState, adaptableStateKey: adaptableOptions.adaptableStateKey }, this.getAdaptableInternalApi().buildBaseContext());
                     this.getAdaptableApi().eventApi.emit('AdaptableStateReloaded', stateReloadedInfo);
                 });
             });
@@ -77,15 +77,14 @@ export class ConfigApiImpl extends ApiBase {
     }
     getPersistedState() {
         // no assertion should be required here as soon as we make order in our state typings
-        return this.adaptable.adaptableStore.getCurrentStorageState();
+        return this.getAdaptableSore().getCurrentStorageState();
     }
     getAllUserState() {
         return Object.values(this.getPersistedState());
     }
     loadUserState(state) {
-        const adaptableOptions = this.adaptable.adaptableOptions;
-        this.setAdaptableStateKey(adaptableOptions.adaptableStateKey, {
-            predefinedConfig: state || adaptableOptions.predefinedConfig,
+        this.setAdaptableStateKey(this.getOptions().adaptableStateKey, {
+            predefinedConfig: state || this.getOptions().predefinedConfig,
             flushCurrentState: false,
         });
     }
@@ -114,40 +113,40 @@ export class ConfigApiImpl extends ApiBase {
     setAdaptableStateKey(adaptableStateKey, config) {
         return new Promise((resolve, reject) => {
             var _a;
-            this.getAdaptableApi().internalApi.executeWithProgressIndicator((_a = config === null || config === void 0 ? void 0 : config.progressIndicatorLabel) !== null && _a !== void 0 ? _a : `Initialising...`, () => {
+            this.getAdaptableInternalApi().executeWithProgressIndicator((_a = config === null || config === void 0 ? void 0 : config.progressIndicatorLabel) !== null && _a !== void 0 ? _a : `Initialising...`, () => {
                 const flushCurrentState = !config || config.flushCurrentState !== false;
                 // make sure we persist any "pending" changes to state - since stateOptions.debounceStateDelay can cause
                 // the state to be persisted with a delay, which we dont want in this case
                 const flushStatePromise = flushCurrentState
-                    ? this.adaptable.adaptableStore.saveStateNow(this.adaptable)
+                    ? this.getAdaptableSore().saveStateNow(this._adaptable)
                     : Promise.resolve(true);
                 flushStatePromise.then(() => {
-                    this.adaptable.adaptableOptions.adaptableStateKey = adaptableStateKey;
+                    this.getOptions().adaptableStateKey = adaptableStateKey;
                     let predefinedConfig = config === null || config === void 0 ? void 0 : config.predefinedConfig;
                     if (predefinedConfig) {
                         predefinedConfig = initPredefinedConfigWithUuids(predefinedConfig);
                     }
-                    const promise = this.adaptable.adaptableStore.loadStore({
-                        adaptable: this.adaptable,
+                    const promise = this.getAdaptableSore().loadStore({
+                        adaptable: this._adaptable,
                         adaptableStateKey,
                         predefinedConfig,
                         postLoadHook: (state) => {
                             const agGridOptions = {
-                                columnDefs: this.adaptable.agGridAdapter.getGridOption('columnDefs'),
-                                autoGroupColumnDef: this.adaptable.agGridAdapter.getGridOption('autoGroupColumnDef'),
-                                rowModelType: this.adaptable.agGridAdapter.getGridOption('rowModelType'),
-                                treeData: this.adaptable.agGridAdapter.getGridOption('treeData'),
+                                columnDefs: this._adaptable.agGridAdapter.getGridOption('columnDefs'),
+                                autoGroupColumnDef: this._adaptable.agGridAdapter.getGridOption('autoGroupColumnDef'),
+                                rowModelType: this._adaptable.agGridAdapter.getGridOption('rowModelType'),
+                                treeData: this._adaptable.agGridAdapter.getGridOption('treeData'),
                             };
-                            return this.adaptable.normalizeAdaptableState(state, agGridOptions);
+                            return this._adaptable.normalizeAdaptableState(state, agGridOptions);
                         },
                     });
                     promise
                         .then(() => {
-                        this.adaptable.updateColumnModelAndRefreshGrid({
+                        this._adaptable.updateColumnModelAndRefreshGrid({
                             preemptiveColumnStateRefresh: true,
                         });
-                        this.adaptable.setLayout();
-                        this.adaptable.applyColumnFiltering();
+                        this._adaptable.setLayout();
+                        this._adaptable.applyColumnFiltering();
                     })
                         .then(() => {
                         // resolve main(result) promise
@@ -167,10 +166,10 @@ export class ConfigApiImpl extends ApiBase {
         });
     }
     getDescriptionForModule(module) {
-        return this.adaptable.ModuleService.getModuleInfoByModule(module).Description;
+        return this._adaptable.ModuleService.getModuleInfoByModule(module).Description;
     }
     getHelpPageForModule(module) {
-        return this.adaptable.ModuleService.getModuleInfoByModule(module).HelpPage;
+        return this._adaptable.ModuleService.getModuleInfoByModule(module).HelpPage;
     }
     getUserStateByStateKey(stateKey, returnJson = false) {
         switch (stateKey) {

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

@@ -1,7 +1,5 @@
 import { ApiBase } from './ApiBase';
 import { ContextMenuApi } from '../ContextMenuApi';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 export declare class ContextMenuApiImpl extends ApiBase implements ContextMenuApi {
-    constructor(adaptable: IAdaptable);
     hideContextMenu(): void;
 }

package/src/Api/Implementation/ContextMenuApiImpl.js

@@ -1,9 +1,6 @@
 import { ApiBase } from './ApiBase';
 export class ContextMenuApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-    }
     hideContextMenu() {
-        this.adaptable.agGridAdapter.getAgGridApi().hidePopupMenu();
+        this.getAgGridApi().hidePopupMenu();
     }
 }

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

@@ -5,7 +5,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { CustomSortInternalApi } from '../Internal/CustomSortInternalApi';
 export declare class CustomSortApiImpl extends ApiBase implements CustomSortApi {
     internalApi: CustomSortInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getCustomSortState(): CustomSortState;
     getCustomSorts(config?: {
         includeLayoutNotAssociatedObjects?: boolean;

package/src/Api/Implementation/CustomSortApiImpl.js

@@ -3,9 +3,9 @@ import * as CustomSortRedux from '../../Redux/ActionsReducers/CustomSortRedux';
 import { ApiBase } from './ApiBase';
 import { CustomSortInternalApi } from '../Internal/CustomSortInternalApi';
 export class CustomSortApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new CustomSortInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new CustomSortInternalApi(_adaptable);
     }
     getCustomSortState() {
         return this.getAdaptableState().CustomSort;

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

@@ -8,7 +8,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { DashboardInternalApi } from '../Internal/DashboardInternalApi';
 export declare class DashboardApiImpl extends ApiBase implements DashboardApi {
     internalApi: DashboardInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getDashboardState(): DashboardState;
     getCustomToolbars(): CustomToolbar[];
     getCustomDashboardButtons(): AdaptableButton<DashboardButtonContext>[];

package/src/Api/Implementation/DashboardApiImpl.js

@@ -5,9 +5,9 @@ import * as React from 'react';
 import { SystemDashboardRefresh } from '../../Redux/ActionsReducers/SystemRedux';
 import { DashboardInternalApi } from '../Internal/DashboardInternalApi';
 export class DashboardApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new DashboardInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new DashboardInternalApi(_adaptable);
     }
     getDashboardState() {
         return this.getAdaptableState().Dashboard;
@@ -20,7 +20,7 @@ export class DashboardApiImpl extends ApiBase {
     }
     getCustomDashboardButtonByLabel(buttonLabel) {
         const api = this.getAdaptableApi();
-        const dashboardContext = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { dashboardState: api.dashboardApi.getDashboardState() });
+        const dashboardContext = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { dashboardState: api.dashboardApi.getDashboardState() });
         return this.getDashboardOptions().customDashboardButtons.find((cb) => {
             api.internalApi.getLabelForButton(cb, dashboardContext) == buttonLabel;
         });
@@ -52,7 +52,7 @@ export class DashboardApiImpl extends ApiBase {
     setCustomToolbarHTMLContent(customToolbarName, htmlContent) {
         let customRenderedContainer = this.getCustomToolbarHTMLElement(customToolbarName);
         if (customRenderedContainer) {
-            this.adaptable.renderReactRoot(React.createElement("div", { dangerouslySetInnerHTML: { __html: htmlContent } }), customRenderedContainer);
+            this._adaptable.renderReactRoot(React.createElement("div", { dangerouslySetInnerHTML: { __html: htmlContent } }), customRenderedContainer);
         }
     }
     getCustomToolbarByName(customToolbarName) {

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

@@ -4,7 +4,7 @@ import { DataImportInternalApi } from '../Internal/DataImportInternalApi';
 import { ApiBase } from './ApiBase';
 export declare class DataImportApiImpl extends ApiBase implements DataImportApi {
     internalApi: DataImportInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     openImportWizard(): void;
     importData(partialRows: any[]): void;
 }

package/src/Api/Implementation/DataImportApiImpl.js

@@ -1,9 +1,9 @@
 import { DataImportInternalApi } from '../Internal/DataImportInternalApi';
 import { ApiBase } from './ApiBase';
 export class DataImportApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new DataImportInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new DataImportInternalApi(_adaptable);
     }
     openImportWizard() {
         this.getSettingsPanelApi().openSettingsPanel('DataImport');

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

@@ -5,7 +5,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { DataSetInternalApi } from '../Internal/DataSetInternalApi';
 export declare class DataSetApiImpl extends ApiBase implements DataSetApi {
     internalApi: DataSetInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getDataSets(): DataSet[];
     getCurrentDataSet(): DataSet | undefined;
     getDataSetByName(dataSetName: string): DataSet | undefined;

package/src/Api/Implementation/DataSetApiImpl.js

@@ -3,13 +3,13 @@ import * as SystemRedux from '../../Redux/ActionsReducers/SystemRedux';
 import { ApiBase } from './ApiBase';
 import { DataSetInternalApi } from '../Internal/DataSetInternalApi';
 export class DataSetApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new DataSetInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new DataSetInternalApi(_adaptable);
     }
     getDataSets() {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this.adaptable.adaptableOptions) === null || _a === void 0 ? void 0 : _a.dataSetOptions) === null || _b === void 0 ? void 0 : _b.dataSets) !== null && _c !== void 0 ? _c : [];
+        var _a, _b;
+        return (_b = (_a = this.getDataSetOptions()) === null || _a === void 0 ? void 0 : _a.dataSets) !== null && _b !== void 0 ? _b : [];
     }
     getCurrentDataSet() {
         let currentDataSetName = this.getAdaptableState().System.CurrentDataSet;

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

@@ -5,7 +5,7 @@ import { EntitlementInternalApi } from '../Internal/EntitlementInternalApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 export declare class EntitlementApiImpl extends ApiBase implements EntitlementApi {
     internalApi: EntitlementInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getEntitlementAccessLevelForModule(adaptableModule: AdaptableModule): AccessLevel;
     isObjectReadonly(object: AdaptableObject): boolean;
     isModuleHiddenEntitlement(adaptableModule: AdaptableModule): boolean;

package/src/Api/Implementation/EntitlementApiImpl.js

@@ -1,21 +1,21 @@
 import { ApiBase } from './ApiBase';
 import { EntitlementInternalApi } from '../Internal/EntitlementInternalApi';
 export class EntitlementApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new EntitlementInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new EntitlementInternalApi(_adaptable);
     }
     getEntitlementAccessLevelForModule(adaptableModule) {
         let entitlementOptions = this.getEntitlementOptions();
         if (entitlementOptions) {
-            const defaultAccessLevelContext = this.getAdaptableApi().internalApi.buildBaseContext();
+            const defaultAccessLevelContext = this.getAdaptableInternalApi().buildBaseContext();
             const defaultAccessLevel = typeof entitlementOptions.defaultAccessLevel === 'function'
                 ? entitlementOptions.defaultAccessLevel(defaultAccessLevelContext)
                 : entitlementOptions.defaultAccessLevel;
             const moduleEntitlements = entitlementOptions.moduleEntitlements;
             if (moduleEntitlements) {
                 if (typeof moduleEntitlements === 'function') {
-                    const entitlementContext = Object.assign(Object.assign({ adaptableModule }, this.getAdaptableApi().internalApi.buildBaseContext()), { defaultAccessLevel });
+                    const entitlementContext = Object.assign(Object.assign({ adaptableModule }, this.getAdaptableInternalApi().buildBaseContext()), { defaultAccessLevel });
                     const dynamicModuleEntitlement = moduleEntitlements(entitlementContext);
                     return dynamicModuleEntitlement !== null && dynamicModuleEntitlement !== void 0 ? dynamicModuleEntitlement : defaultAccessLevel;
                 }

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

@@ -4,7 +4,7 @@ import { EventApi } from '../EventApi';
 import { EmitterCallback } from '../../Utilities/Emitter';
 export declare class EventApiImpl extends ApiBase implements EventApi {
     private emitter;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     destroy(): void;
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     off: (eventName: string, callback: EmitterCallback) => void;

package/src/Api/Implementation/EventApiImpl.js

@@ -1,8 +1,8 @@
 import { ApiBase } from './ApiBase';
 import Emitter from '../../Utilities/Emitter';
 export class EventApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
         this.on = (eventName, callback) => {
             let result;
             if (eventName === 'AdaptableReady') {

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

@@ -8,7 +8,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ExportInternalApi } from '../Internal/ExportInternalApi';
 export declare class ExportApiImpl extends ApiBase implements ExportApi {
     internalApi: ExportInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getExportState(): ExportState;
     getCurrentReportName(): string;
     getCurrentReport(): Report;

package/src/Api/Implementation/ExportApiImpl.js

@@ -6,9 +6,9 @@ import ObjectFactory from '../../Utilities/ObjectFactory';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { ExportInternalApi } from '../Internal/ExportInternalApi';
 export class ExportApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ExportInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ExportInternalApi(_adaptable);
     }
     getExportState() {
         return this.getAdaptableState().Export;
@@ -97,10 +97,10 @@ export class ExportApiImpl extends ApiBase {
         return (_a = this.getCustomDestinations().find((destination) => destination.name === destinationName)) === null || _a === void 0 ? void 0 : _a.form;
     }
     canExportToExcel() {
-        return this.adaptable.canExportToExcel();
+        return this._adaptable.canExportToExcel();
     }
     exportDataToExcel(reportData, fileName) {
-        this.adaptable.exportToExcel(reportData, fileName);
+        this._adaptable.exportToExcel(reportData, fileName);
     }
     openExportSettingsPanel() {
         this.showModulePopup(ModuleConstants.ExportModuleId);
@@ -116,7 +116,7 @@ export class ExportApiImpl extends ApiBase {
         return reports === null || reports === void 0 ? void 0 : reports.map((report) => this.getReportById(report.Uuid));
     }
     exportVisualDataToExcel() {
-        this.adaptable.exportVisualDataToExcel();
+        this._adaptable.exportVisualDataToExcel();
     }
     getExternalReports() {
         var _a;
@@ -146,7 +146,7 @@ export class ExportApiImpl extends ApiBase {
     isColumnExportable(adaptableColumn) {
         const isExportableFn = this.getExportOptions().isColumnExportable;
         if (typeof isExportableFn === 'function') {
-            return isExportableFn(Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { adaptableColumn }));
+            return isExportableFn(Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { adaptableColumn }));
         }
         return true;
     }

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

@@ -7,7 +7,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ExpressionInternalApi } from '../Internal/ExpressionInternalApi';
 export declare class ExpressionApiImpl extends ApiBase implements ExpressionApi {
     internalApi: ExpressionInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     isValidBooleanExpression(query: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     isValidObservableExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;
     isValidAggregatedBooleanExpression(expression: string, module: AdaptableModule, validationErrorMessage?: string): boolean;

package/src/Api/Implementation/ExpressionApiImpl.js

@@ -2,9 +2,9 @@ import { ApiBase } from './ApiBase';
 import * as parser from '../../parser/src';
 import { ExpressionInternalApi } from '../Internal/ExpressionInternalApi';
 export class ExpressionApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ExpressionInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ExpressionInternalApi(_adaptable);
     }
     isValidBooleanExpression(query, module, validationErrorMessage) {
         const { isValid, errorMessage } = this.getAdaptableApi()
@@ -69,7 +69,7 @@ export class ExpressionApiImpl extends ApiBase {
     isColumnQueryable(adaptableColumnBase) {
         let queryableColumnFn = this.getExpressionOptions().isColumnQueryable;
         if (queryableColumnFn) {
-            const queryableColumnContext = Object.assign({ adaptableColumn: adaptableColumnBase }, this.getAdaptableApi().internalApi.buildBaseContext());
+            const queryableColumnContext = Object.assign({ adaptableColumn: adaptableColumnBase }, this.getAdaptableInternalApi().buildBaseContext());
             return queryableColumnFn(queryableColumnContext);
         }
         return true;
@@ -84,6 +84,6 @@ export class ExpressionApiImpl extends ApiBase {
             .getExpressionWithColumnFriendlyNames(this.getAdaptableQueryExpression(query));
     }
     useCaseSensitivity() {
-        return this.adaptable.adaptableOptions.expressionOptions.caseSensitiveExpressions;
+        return this.getExpressionOptions().caseSensitiveExpressions;
     }
 }

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

@@ -7,7 +7,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AppIdentifier } from '@finos/fdc3/dist/api/AppIdentifier';
 export declare class Fdc3ApiImpl extends ApiBase implements Fdc3Api {
     internalApi: Fdc3InternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getDesktopAgent(): DesktopAgent;
     buildContextDataFromRow(contextType: ContextType, rowNode: IRowNode): Context;
     buildContextDataForPrimaryKey(contextType: ContextType, primaryKeyValue: string | number): Context | undefined;

package/src/Api/Implementation/Fdc3ApiImpl.js

@@ -2,9 +2,9 @@ import { ApiBase } from './ApiBase';
 import { Fdc3InternalApi } from '../Internal/Fdc3InternalApi';
 import { ContextConfiguration } from '../../PredefinedConfig/Common/Fdc3Context';
 export class Fdc3ApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new Fdc3InternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new Fdc3InternalApi(_adaptable);
     }
     getDesktopAgent() {
         return this.getFdc3Service().getDesktopAgent();
@@ -69,7 +69,7 @@ export class Fdc3ApiImpl extends ApiBase {
         return this.internalApi.isStandardIntentType(intentType);
     }
     getFdc3Service() {
-        return this.getAdaptableApi().internalApi.getFdc3Service();
+        return this.getAdaptableInternalApi().getFdc3Service();
     }
     getPossibleContextTypes(intent) {
         this.logWarn('Fdc3Api.getPossibleContextTypes is NO longer relevant as of FDC3 v1.2 and will be removed in a future version');

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

@@ -9,7 +9,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableObjectLookupCriteria } from '../../types';
 export declare class FlashingCellApiImpl extends ApiBase implements FlashingCellApi {
     internalApi: FlashingCellInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getFlashingCellState(): FlashingCellState;
     getFlashingCellDefinitions(config?: LayoutAssociatedObjectLoadConfig): FlashingCellDefinition[];
     getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid']): FlashingCellDefinition;

package/src/Api/Implementation/FlashingCellApiImpl.js

@@ -2,9 +2,9 @@ import * as FlashingCellRedux from '../../Redux/ActionsReducers/FlashingCellRedu
 import { ApiBase } from './ApiBase';
 import { FlashingCellInternalApi } from '../Internal/FlashingCellInternalApi';
 export class FlashingCellApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new FlashingCellInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new FlashingCellInternalApi(_adaptable);
     }
     getFlashingCellState() {
         return this.getAdaptableState().FlashingCell;
@@ -32,7 +32,7 @@ export class FlashingCellApiImpl extends ApiBase {
     }
     showFlashingCell(flashingCellToShow) {
         this.addUidToAdaptableObject(flashingCellToShow);
-        const flashingCellFiredInfo = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { flashingCell: flashingCellToShow });
+        const flashingCellFiredInfo = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { flashingCell: flashingCellToShow });
         const results = this.getAdaptableApi().eventApi.emitSync('FlashingCellDisplayed', flashingCellFiredInfo);
         const shouldShow = results.reduce((endResult, aResult) => {
             return endResult && aResult !== false;
@@ -94,13 +94,13 @@ export class FlashingCellApiImpl extends ApiBase {
             .filter((predicateDef) => this.getAdaptableApi().columnScopeApi.isScopeInScope(scope, predicateDef.columnScope));
     }
     clearAllFlashingCells() {
-        this.getAdaptableApi().internalApi.getFlashingCellService().clearAllGridCellFlashes();
+        this.getAdaptableInternalApi().getFlashingCellService().clearAllGridCellFlashes();
     }
     isAnyFlashingCellActive() {
-        return this.getAdaptableApi().internalApi.getFlashingCellService().isAnyFlashingCellActive();
+        return this.getAdaptableInternalApi().getFlashingCellService().isAnyFlashingCellActive();
     }
     findFlashingCellDefinitions(criteria) {
-        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getFlashingCellDefinitions({
+        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getFlashingCellDefinitions({
             includeLayoutNotAssociatedObjects: true,
         }));
     }

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

@@ -8,7 +8,7 @@ import { FormatColumnInternalApi } from '../Internal/FormatColumnInternalApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 export declare class FormatColumnApiImpl extends ApiBase implements FormatColumnApi {
     internalApi: FormatColumnInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getFormatColumnState(): FormatColumnState;
     getFormatColumns(config?: {
         includeLayoutNotAssociatedObjects?: boolean;