@adaptabletools/adaptable 19.1.0 → 19.1.2-canary.0

package/src/Api/Implementation/ChartingApiImpl.js

@@ -5,18 +5,18 @@ import ObjectFactory from '../../Utilities/ObjectFactory';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { ChartingInternalApi } from '../Internal/ChartingInternalApi';
 export class ChartingApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ChartingInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ChartingInternalApi(_adaptable);
     }
     isChartingEnabled() {
-        return this.adaptable.canGenerateCharts();
+        return this._adaptable.canGenerateCharts();
     }
     getCurrentChartModels() {
-        return this.adaptable.getChartModels();
+        return this._adaptable.getChartModels();
     }
     getChartRef(chartId) {
-        return this.adaptable.getChartRef(chartId);
+        return this._adaptable.getChartRef(chartId);
     }
     saveCurrentCharts() {
         const currentCharts = this.getCurrentChartModels();
@@ -45,14 +45,14 @@ export class ChartingApiImpl extends ApiBase {
         }
     }
     showPersistedCharts() {
-        return this.adaptable.showCharts(this.getChartDefinitions());
+        return this._adaptable.showCharts(this.getChartDefinitions());
     }
     showChartDefinition(chartDefiniton, container) {
         let containerElement = container;
         if (typeof containerElement === 'string') {
             containerElement = this.internalApi.getContainerElemetnByName(containerElement);
         }
-        return this.adaptable.showChart(chartDefiniton, containerElement);
+        return this._adaptable.showChart(chartDefiniton, containerElement);
     }
     showChartDefinitionOnce(chartDefinition, container) {
         var _a;
@@ -73,7 +73,7 @@ export class ChartingApiImpl extends ApiBase {
         this.updateAgChart(editedChartDefinition);
     }
     updateAgChart(chartDefinition) {
-        this.adaptable.updateChart(chartDefinition);
+        this._adaptable.updateChart(chartDefinition);
     }
     addChartDefinition(chart) {
         this.dispatchAction(ChartingRedux.ChartingAddChart(chart));

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

@@ -8,7 +8,7 @@ export declare function isAutoRowGroupColumn(columnId: string): boolean;
 export declare function isAutoPivotColumn(columnId: string): boolean;
 export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     internalApi: ColumnInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getColumns(): AdaptableColumn[];
     getStandardColumns(): AdaptableColumn[];
     getNonSpecialColumns(): AdaptableColumn[];

package/src/Api/Implementation/ColumnApiImpl.js

@@ -17,9 +17,9 @@ export function isAutoPivotColumn(columnId) {
     return columnId === null || columnId === void 0 ? void 0 : columnId.startsWith(GeneralConstants.AG_GRID_PIVOT_COLUMN);
 }
 export class ColumnApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ColumnInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ColumnInternalApi(_adaptable);
     }
     getColumns() {
         var _a;
@@ -44,34 +44,34 @@ export class ColumnApiImpl extends ApiBase {
         return this.getColumns().filter((c) => visibleCols[c.columnId]);
     }
     selectColumn(columnId) {
-        this.adaptable.selectColumn(columnId);
+        this._adaptable.selectColumn(columnId);
     }
     selectColumns(columnIds) {
-        this.adaptable.selectColumns(columnIds);
+        this._adaptable.selectColumns(columnIds);
     }
     addColumnToSelection(columnId) {
-        this.adaptable.selectColumn(columnId, { keepExistingSelection: true });
+        this._adaptable.selectColumn(columnId, { keepExistingSelection: true });
     }
     addColumnsToSelection(columnIds) {
-        this.adaptable.selectColumns(columnIds, { keepExistingSelection: true });
+        this._adaptable.selectColumns(columnIds, { keepExistingSelection: true });
     }
     selectAllColumns() {
-        this.adaptable.selectAll();
+        this._adaptable.selectAll();
     }
     autosizeColumn(columnId) {
-        this.adaptable.autoSizeColumn(columnId);
+        this._adaptable.autoSizeColumn(columnId);
     }
     autosizeColumns(columnIds) {
-        this.adaptable.autoSizeColumns(columnIds);
+        this._adaptable.autoSizeColumns(columnIds);
     }
     autosizeAllColumns() {
-        this.adaptable.autoSizeAllColumns();
+        this._adaptable.autoSizeAllColumns();
     }
     hideColumn(columnId) {
-        this.adaptable.hideColumn(columnId);
+        this._adaptable.hideColumn(columnId);
     }
     showColumn(columnId) {
-        this.adaptable.showColumn(columnId);
+        this._adaptable.showColumn(columnId);
     }
     isAutoRowGroupColumn(columnId) {
         return isAutoRowGroupColumn(columnId);
@@ -328,7 +328,7 @@ export class ColumnApiImpl extends ApiBase {
         return this.getColumns().filter((c) => c.exportable);
     }
     logMissingColumnWarning(columnId) {
-        if (this.adaptable.adaptableOptions.columnOptions.showMissingColumnsWarning === true) {
+        if (this.getColumnOptions().showMissingColumnsWarning === true) {
             if (!this.isAutoRowGroupColumn(columnId) &&
                 !this.isCalculatedColumn(columnId) &&
                 !this.isFreeTextColumn(columnId) &&
@@ -338,7 +338,7 @@ export class ColumnApiImpl extends ApiBase {
         }
     }
     getPrimaryKeyColumn() {
-        return this.getColumnWithColumnId(this.adaptable.adaptableOptions.primaryKey);
+        return this.getColumnWithColumnId(this.getOptions().primaryKey);
     }
     getDefaultAggFunc(columnId) {
         var _a, _b, _c;
@@ -385,15 +385,15 @@ export class ColumnApiImpl extends ApiBase {
         return this.getAdaptableApi().layoutApi.setColumnCaption(columnId, caption);
     }
     updateColumnConfiguration(columnConfig) {
-        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'updateColumnConfiguration', 'GridApi', 'updateAgGridColumnState');
+        logDeprecationExternal(this.getAdatableLogger(), 'ColumnApi', 'updateColumnConfiguration', 'GridApi', 'updateAgGridColumnState');
         this.getGridApi().updateAgGridColumnState(columnConfig);
     }
     updateColumnConfigurations(columnConfigs) {
-        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'updateColumnConfigurations', 'GridApi', 'updateAgGridColumnStates');
+        logDeprecationExternal(this.getAdatableLogger(), 'ColumnApi', 'updateColumnConfigurations', 'GridApi', 'updateAgGridColumnStates');
         this.getGridApi().updateAgGridColumnStates(columnConfigs);
     }
     setColumnDefinitions(columnDefinitions) {
-        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'setColumnDefinitions', 'GridApi', 'setAgGridColumnDefinitions');
+        logDeprecationExternal(this.getAdatableLogger(), 'ColumnApi', 'setColumnDefinitions', 'GridApi', 'setAgGridColumnDefinitions');
         this.getGridApi().setAgGridColumnDefinitions(columnDefinitions);
     }
 }

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

@@ -7,7 +7,7 @@ import { ColumnFilterInternalApi } from '../Internal/ColumnFilterInternalApi';
 import { ColumnFilterApi } from '../ColumnFilterApi';
 export declare class ColumnFilterApiImpl extends ApiBase implements ColumnFilterApi {
     internalApi: ColumnFilterInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getFilterPredicateDefsForColumn(column: AdaptableColumn): AdaptablePredicateDef[];
     getFilterPredicateDefsForColumnId(columnId: string): AdaptablePredicateDef[] | undefined;
     showQuickFilterBar(): void;

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;