@adaptabletools/adaptable 19.1.0-canary.0 → 19.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "19.1.0-canary.0",
+  "version": "19.1.1",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableOptions/FormatColumnOptions.d.ts

@@ -16,19 +16,19 @@ export interface FormatColumnOptions {
  */
 export interface CustomDisplayFormatter {
     /**
-     * Format Id
+     * Custom Format Id
      */
     id: string;
     /**
-     * Format Description
+     * Custom Format Description
      */
     label?: string;
     /**
-     * Function used to render Custom Display Format
+     * Function used to render the Custom Display Format
      */
     handler: (customDisplayFormatterContext: CustomDisplayFormatterContext) => any;
     /**
-     * Where Custom Display Format can be applied
+     * Used by Format Columns wizard to show where Custom Display Format can be applied
      */
     scope: ColumnScope;
 }

package/src/Api/GridApi.d.ts

@@ -456,7 +456,8 @@ export interface GridApi {
      * @param rowNodes agGrid RowNodes which contain cells to refresh
      * @param columnIds ColumnIds which contain cells to refresh
      */
-    refreshCells(rowNodes: IRowNode[], columnIds: string[]): void;
+    refreshCells(rowNodes: IRowNode[], columnIds: string[], suppressFlash?: boolean): void;
+    refreshAllCells(forceUpdate?: boolean): void;
     /**
      * Refreshes a single Grid Cell
      * @param gridCell GridCell to refresh

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

@@ -1,9 +1,7 @@
 import { ActionColumn, ActionColumnApi } from '../../../types';
 import { ApiBase } from './ApiBase';
-import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ColDef } from '@ag-grid-community/core';
 export declare class ActionColumnApiImpl extends ApiBase implements ActionColumnApi {
-    constructor(adaptable: IAdaptable);
     getActionColumns(): ActionColumn[];
     getColDefsForActionColumns(): ColDef[];
 }

package/src/Api/Implementation/ActionColumnApiImpl.js

@@ -2,9 +2,6 @@ import { ApiBase } from './ApiBase';
 import { ActionColumnRenderer, ReactActionColumnRenderer } from '../../agGrid/ActionColumnRenderer';
 import { AB_SPECIAL_COLUMN } from '../../Utilities/Constants/GeneralConstants';
 export class ActionColumnApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-    }
     getActionColumns() {
         var _a;
         return (_a = this.getActionColumnOptions().actionColumns) !== null && _a !== void 0 ? _a : [];
@@ -28,7 +25,7 @@ export class ActionColumnApiImpl extends ApiBase {
                 filter: false,
                 sortable: false,
                 enableRowGroup: false,
-                cellRenderer: this.getAdaptableApi().internalApi.getAdaptableInstance().variant === 'react'
+                cellRenderer: this.getGridApi().getVariant() === 'react'
                     ? ReactActionColumnRenderer
                     : ActionColumnRenderer,
                 type: [AB_SPECIAL_COLUMN, 'abColDefObject'],

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

@@ -4,7 +4,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ActionRowInternalApi } from '../Internal/ActionRowInternalApi';
 export declare class ActionRowApiImpl extends ApiBase implements ActionRowApi {
     internalApi: ActionRowInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getActionRowButtons(): ActionRowButtonType[];
     displayEditActionRow(primaryKey: any): void;
     displayCreateActionRow(): void;

package/src/Api/Implementation/ActionRowApiImpl.js

@@ -2,14 +2,14 @@ import { PopupShowForm } from '../../Redux/ActionsReducers/PopupRedux';
 import { ApiBase } from './ApiBase';
 import { ActionRowInternalApi } from '../Internal/ActionRowInternalApi';
 export class ActionRowApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new ActionRowInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ActionRowInternalApi(_adaptable);
     }
     getActionRowButtons() {
         var actionRowButtons = this.getActionRowOptions().actionRowButtons;
         if (typeof actionRowButtons === 'function') {
-            const context = this.getAdaptableApi().internalApi.buildBaseContext();
+            const context = this.getAdaptableInternalApi().buildBaseContext();
             actionRowButtons = actionRowButtons(context);
         }
         return actionRowButtons !== null && actionRowButtons !== void 0 ? actionRowButtons : [];

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

@@ -110,10 +110,12 @@ export declare class AdaptableApiImpl implements AdaptableApi {
         destroyApi?: boolean;
     }): void;
     isDestroyed(): boolean;
+    logConsoleMessage(message: string, ...optionalParams: any[]): void;
     logInfo(message: string, ...optionalParams: any[]): void;
     logSuccess(message: string, ...optionalParams: any[]): void;
     logWarn(message: string, ...optionalParams: any[]): void;
     logError(message: string, ...optionalParams: any[]): void;
+    consoleLog(message: string, ...optionalParams: any[]): void;
     consoleError(message: string, ...optionalParams: any[]): void;
     consoleWarn(message: string, ...optionalParams: any[]): void;
 }

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -166,6 +166,9 @@ export class AdaptableApiImpl {
     isDestroyed() {
         return this.destroyed;
     }
+    logConsoleMessage(message, ...optionalParams) {
+        this.adaptable.logger.consoleLog(message, optionalParams);
+    }
     logInfo(message, ...optionalParams) {
         this.adaptable.logger.info(message, optionalParams);
     }
@@ -178,6 +181,9 @@ export class AdaptableApiImpl {
     logError(message, ...optionalParams) {
         this.adaptable.logger.error(message, optionalParams);
     }
+    consoleLog(message, ...optionalParams) {
+        this.adaptable.logger.consoleLog(message, optionalParams);
+    }
     consoleError(message, ...optionalParams) {
         this.adaptable.logger.consoleError(message, optionalParams);
     }

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

@@ -8,7 +8,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AlertInternalApi } from '../Internal/AlertInternalApi';
 export declare class AlertApiImpl extends ApiBase implements AlertApi {
     internalApi: AlertInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getAlertState(): AlertState;
     getAlertDefinitions(config?: LayoutAssociatedObjectLoadConfig): AlertDefinition[];
     getSuspendedAlertDefinitions(config?: {

package/src/Api/Implementation/AlertApiImpl.js

@@ -8,9 +8,9 @@ import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { AlertInternalApi } from '../Internal/AlertInternalApi';
 export class AlertApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new AlertInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new AlertInternalApi(_adaptable);
     }
     getAlertState() {
         return this.getAdaptableState().Alert;
@@ -43,7 +43,7 @@ export class AlertApiImpl extends ApiBase {
         this.addUidToAdaptableObject(alertToShow);
         this.dispatchAction(SystemRedux.SystemAlertAdd(alertToShow, this.getAlertOptions().maxAlertsInStore));
         // 2. Publish the Alert Fired Event
-        const alertFiredInfo = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { alert: alertToShow });
+        const alertFiredInfo = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { alert: alertToShow });
         const results = await this.getAdaptableApi().eventApi.emit('AlertFired', alertFiredInfo);
         const showPopup = results.reduce((endResult, aResult) => {
             return endResult && aResult !== false;
@@ -59,7 +59,7 @@ export class AlertApiImpl extends ApiBase {
             }
             // 2. Log to console
             if (alertProperties.LogToConsole) {
-                this.adaptable.logger.consoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
+                this.getAdatableLogger().consoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
             }
             // 3. Show it in a Div (if one has been set)
             if (alertProperties.ShowInDiv) {
@@ -79,7 +79,7 @@ export class AlertApiImpl extends ApiBase {
             if (alertProperties.JumpToCell &&
                 isAdaptableCellChangedAlert(alertToShow) &&
                 alertToShow.cellDataChangedInfo) {
-                this.adaptable.jumpToCell(alertToShow.cellDataChangedInfo.column.columnId, alertToShow.cellDataChangedInfo.rowNode);
+                this._adaptable.jumpToCell(alertToShow.cellDataChangedInfo.column.columnId, alertToShow.cellDataChangedInfo.rowNode);
             }
             // 5: Jump to the Row
             else if (alertProperties.JumpToRow &&
@@ -87,7 +87,7 @@ export class AlertApiImpl extends ApiBase {
                 ((_a = alertToShow.gridDataChangedInfo) === null || _a === void 0 ? void 0 : _a.rowTrigger) === 'Add') {
                 const [firstRowNode] = alertToShow.gridDataChangedInfo.rowNodes;
                 if (firstRowNode) {
-                    this.adaptable.jumpToRow(firstRowNode);
+                    this._adaptable.jumpToRow(firstRowNode);
                 }
             }
             // 6: For CellChanged Alerts either Highlight the cell or row
@@ -97,20 +97,20 @@ export class AlertApiImpl extends ApiBase {
                 (alertProperties.HighlightCell || alertProperties.HighlightRow)) {
                 let alertNode = alertToShow.cellDataChangedInfo.rowNode;
                 if (!alertNode) {
-                    alertNode = this.adaptable.getRowNodeForPrimaryKey(alertToShow.cellDataChangedInfo.primaryKeyValue);
+                    alertNode = this.getGridApi().getRowNodeForPrimaryKey(alertToShow.cellDataChangedInfo.primaryKeyValue);
                 }
                 if (alertNode) {
                     if (alertProperties.HighlightRow) {
                         this.getAdaptableApi().gridApi.refreshRowNodes([alertNode]);
                         setTimeout(() => {
                             this.dispatchAction(SystemRedux.SystemAlertRemoveRowHighlight(alertToShow));
-                        }, this.adaptable.adaptableOptions.alertOptions.rowHighlightDuration);
+                        }, this.getAlertOptions().rowHighlightDuration);
                     }
                     if (alertProperties.HighlightCell) {
                         this.getAdaptableApi().gridApi.refreshCells([alertNode], [alertToShow.cellDataChangedInfo.column.columnId]);
                         setTimeout(() => {
                             this.dispatchAction(SystemRedux.SystemAlertRemoveCellHighlight(alertToShow));
-                        }, this.adaptable.adaptableOptions.alertOptions.cellHighlightDuration);
+                        }, this.getAlertOptions().cellHighlightDuration);
                     }
                 }
             }
@@ -121,7 +121,7 @@ export class AlertApiImpl extends ApiBase {
                 this.getAdaptableApi().gridApi.refreshRowNodes(alertToShow.gridDataChangedInfo.rowNodes);
                 setTimeout(() => {
                     this.dispatchAction(SystemRedux.SystemAlertRemoveRowHighlight(alertToShow));
-                }, this.adaptable.adaptableOptions.alertOptions.rowHighlightDuration);
+                }, this.getAlertOptions().rowHighlightDuration);
             }
         }
     }
@@ -195,7 +195,7 @@ export class AlertApiImpl extends ApiBase {
         });
     }
     findAlertDefinitions(criteria) {
-        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions({
+        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions({
             includeLayoutNotAssociatedObjects: true,
         }));
     }
@@ -220,11 +220,12 @@ export class AlertApiImpl extends ApiBase {
     }
     createCellDataChangeInfoStubs(relevantColumnIds) {
         const cellDataChangeInfos = [];
+        //const adaptable: IAdaptable = this.getAdaptableInternalApi().getAdaptableInstance();
         const relevantColumns = this.getAdaptableApi()
             .columnApi.getColumnsWithColumnIds(relevantColumnIds)
             .filter(Boolean);
         const changedAt = Date.now();
-        this.adaptable.forAllRowNodesDo((rowNode) => {
+        this.getAdaptableInternalApi().forAllRowNodesDo((rowNode) => {
             relevantColumns.forEach((column) => {
                 const cellDataChangeInfoStub = {
                     changedAt,
@@ -232,8 +233,8 @@ export class AlertApiImpl extends ApiBase {
                     column,
                     rowData: rowNode.data,
                     oldValue: null,
-                    newValue: this.adaptable.getRawValueFromRowNode(rowNode, column.columnId),
-                    primaryKeyValue: this.adaptable.getPrimaryKeyValueFromRowNode(rowNode),
+                    newValue: this.getGridApi().getRawValueFromRowNode(rowNode, column.columnId),
+                    primaryKeyValue: this.getGridApi().getPrimaryKeyValueForRowNode(rowNode),
                 };
                 cellDataChangeInfos.push(cellDataChangeInfoStub);
             });

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

@@ -6,21 +6,27 @@ import { AdaptableObject } from '../../PredefinedConfig/Common/AdaptableObject';
 import { ModuleInfo } from '../../Strategy/Interface/IModule';
 import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
+import { GridApi as AgGridApi } from '@ag-grid-community/core';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
 import { ActionColumnApi, ActionColumnOptions, ActionRowApi, ActionRowOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, ColumnFilterApi, ColumnFilterOptions, ColumnOptions, CommentOptions, ConfigApi, ContainerOptions, CustomSortApi, CustomSortOptions, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataChangeHistoryOptions, DataSetApi, DataSetOptions, EditOptions, EntitlementApi, EntitlementOptions, EventApi, ExportApi, ExpressionApi, ExpressionOptions, Fdc3Api, Fdc3Options, FlashingCellApi, FlashingCellOptions, FormatColumnApi, FormatColumnOptions, FreeTextColumnApi, GridApi, GridFilterApi, GroupingOptions, LayoutApi, LayoutAssociatedObject, LayoutOptions, NamedQueryApi, NoteOptions, NotificationsOptions, PluginsApi, PlusMinusApi, PredicateApi, PredicateOptions, QuickSearchApi, QuickSearchOptions, ScheduleApi, ColumnScopeApi, SettingsPanelApi, SettingsPanelOptions, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, ToolPanelOptions, UserInterfaceApi, UserInterfaceOptions, ColumnMenuOptions, ContextMenuOptions } from '../../types';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
+import { AdaptableInternalApi } from '../Internal/AdaptableInternalApi';
+import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
+import { IAdaptableStore } from '../../Redux/Store/Interface/IAdaptableStore';
 export declare abstract class ApiBase {
-    protected adaptable: IAdaptable;
+    protected _adaptable: IAdaptable;
     /**
      * Constructor for all the api classes which simply takes and assigns an instance of Adaptable
-     * @param adaptable the core IAdaptable object
+     * @param _adaptable the core IAdaptable object
      */
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
+    protected getAdatableLogger(): AdaptableLogger;
     protected logInfo(message: string, ...optionalParams: any[]): void;
     protected logSuccess(message: string, ...optionalParams: any[]): void;
     protected logWarn(message: string, ...optionalParams: any[]): void;
     protected logError(message: string, ...optionalParams: any[]): void;
     protected getAdaptableVariant(): AdaptableVariant;
+    protected isAdapTableReady(): boolean;
     /**
      * Base api helper method which ensure that Adaptable Object being used in the function is not null or undefined
      *
@@ -46,6 +52,7 @@ export declare abstract class ApiBase {
      * This is a simple *getState()* call
      */
     getAdaptableState(): AdaptableState;
+    protected getAdaptableSore(): IAdaptableStore;
     protected addUidToAdaptableObject(adaptableObject: AdaptableObject): void;
     protected getModuleInfoByModuleId(module: AdaptableModule): ModuleInfo;
     protected showModulePopup(module: AdaptableModule, moduleParams?: ModuleParams): void;
@@ -85,6 +92,8 @@ export declare abstract class ApiBase {
     protected getSettingsPanelOptions(): SettingsPanelOptions;
     protected getFdc3Options(): Fdc3Options;
     protected getAdaptableApi(): AdaptableApi;
+    protected getAgGridApi(): AgGridApi;
+    protected getAdaptableInternalApi(): AdaptableInternalApi;
     protected getActionColumnApi(): ActionColumnApi;
     protected getActionRowApi(): ActionRowApi;
     protected getApplicationApi(): ApplicationApi;

package/src/Api/Implementation/ApiBase.js

@@ -4,25 +4,31 @@ import { createUuid } from '../../PredefinedConfig/Uuid';
 export class ApiBase {
     /**
      * Constructor for all the api classes which simply takes and assigns an instance of Adaptable
-     * @param adaptable the core IAdaptable object
+     * @param _adaptable the core IAdaptable object
      */
-    constructor(adaptable) {
-        this.adaptable = adaptable;
+    constructor(_adaptable) {
+        this._adaptable = _adaptable;
+    }
+    getAdatableLogger() {
+        return this._adaptable.logger;
     }
     logInfo(message, ...optionalParams) {
-        this.adaptable.logger.info(message, ...optionalParams);
+        this._adaptable.logger.info(message, ...optionalParams);
     }
     logSuccess(message, ...optionalParams) {
-        this.adaptable.logger.success(message, ...optionalParams);
+        this._adaptable.logger.success(message, ...optionalParams);
     }
     logWarn(message, ...optionalParams) {
-        this.adaptable.logger.warn(message, ...optionalParams);
+        this._adaptable.logger.warn(message, ...optionalParams);
     }
     logError(message, ...optionalParams) {
-        this.adaptable.logger.error(message, ...optionalParams);
+        this._adaptable.logger.error(message, ...optionalParams);
     }
     getAdaptableVariant() {
-        return this.adaptable.variant;
+        return this._adaptable.variant;
+    }
+    isAdapTableReady() {
+        return this._adaptable.isReady;
     }
     /**
      * Base api helper method which ensure that Adaptable Object being used in the function is not null or undefined
@@ -51,19 +57,19 @@ export class ApiBase {
             return objectList;
         }
         const associatedLayout = (config === null || config === void 0 ? void 0 : config.associatedWithLayout)
-            ? this.adaptable.api.layoutApi.getLayoutByName(config.associatedWithLayout)
+            ? this._adaptable.api.layoutApi.getLayoutByName(config.associatedWithLayout)
             : this.getAdaptableApi().layoutApi.getCurrentLayout();
-        return objectList.filter((objectItem) => this.adaptable.api.layoutApi.internalApi.isObjectAvailableInLayout(objectItem, module, associatedLayout));
+        return objectList.filter((objectItem) => this._adaptable.api.layoutApi.internalApi.isObjectAvailableInLayout(objectItem, module, associatedLayout));
     }
     /**
      * Base api Helper method that dispatches a *Redux Action* to the Store
      * @param action the Redux Action to be dispatched
      */
     dispatchAction(action) {
-        if (this.adaptable.isDestroyed) {
+        if (this._adaptable.isDestroyed) {
             return;
         }
-        this.adaptable.adaptableStore.TheStore.dispatch(action);
+        this._adaptable.adaptableStore.TheStore.dispatch(action);
     }
     /**
      * Returns the entire State from the Store
@@ -71,7 +77,10 @@ export class ApiBase {
      * This is a simple *getState()* call
      */
     getAdaptableState() {
-        return this.adaptable.adaptableStore.TheStore.getState();
+        return this.getAdaptableSore().TheStore.getState();
+    }
+    getAdaptableSore() {
+        return this._adaptable.adaptableStore;
     }
     // Add the Uuid to the object if not present;
     // It's generally done in Redux also but no harm checking in Api also in case we missed it.
@@ -81,16 +90,16 @@ export class ApiBase {
         }
     }
     getModuleInfoByModuleId(module) {
-        return this.adaptable.ModuleService.getModuleInfoByModule(module);
+        return this._adaptable.ModuleService.getModuleInfoByModule(module);
     }
     showModulePopup(module, moduleParams) {
         let moduleInfo = this.getModuleInfoByModuleId(module);
         if (moduleInfo) {
-            this.adaptable.api.internalApi.showPopupScreen(moduleInfo.ModuleName, moduleInfo.Popup, moduleParams);
+            this._adaptable.api.internalApi.showPopupScreen(moduleInfo.ModuleName, moduleInfo.Popup, moduleParams);
         }
     }
     getOptions() {
-        return this.adaptable.adaptableOptions;
+        return this._adaptable.adaptableOptions;
     }
     getActionColumnOptions() {
         return this.getOptions().actionColumnOptions;
@@ -177,25 +186,31 @@ export class ApiBase {
         return this.getOptions().toolPanelOptions;
     }
     getChartingOptions() {
-        return this.adaptable.adaptableOptions.chartingOptions;
+        return this.getOptions().chartingOptions;
     }
     getDataChangeHistoryOptions() {
-        return this.adaptable.adaptableOptions.dataChangeHistoryOptions;
+        return this.getOptions().dataChangeHistoryOptions;
     }
     getEntitlementOptions() {
-        return this.adaptable.adaptableOptions.entitlementOptions;
+        return this.getOptions().entitlementOptions;
     }
     getFlashingCellOptions() {
-        return this.adaptable.adaptableOptions.flashingCellOptions;
+        return this.getOptions().flashingCellOptions;
     }
     getSettingsPanelOptions() {
-        return this.adaptable.adaptableOptions.settingsPanelOptions;
+        return this.getOptions().settingsPanelOptions;
     }
     getFdc3Options() {
-        return this.adaptable.adaptableOptions.fdc3Options;
+        return this.getOptions().fdc3Options;
     }
     getAdaptableApi() {
-        return this.adaptable.api;
+        return this._adaptable.api;
+    }
+    getAgGridApi() {
+        return this.getAdaptableApi().agGridApi;
+    }
+    getAdaptableInternalApi() {
+        return this.getAdaptableApi().internalApi;
     }
     getActionColumnApi() {
         return this.getAdaptableApi().actionColumnApi;
@@ -330,6 +345,6 @@ export class ApiBase {
         return this.getAdaptableApi().fdc3Api;
     }
     destroy() {
-        delete this.adaptable;
+        delete this._adaptable;
     }
 }

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

@@ -5,7 +5,7 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { CalculatedColumnInternalApi } from '../Internal/CalculatedColumnInternalApi';
 export declare class CalculatedColumnApiImpl extends ApiBase implements CalculatedColumnApi {
     internalApi: CalculatedColumnInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getCalculatedColumnState(): CalculatedColumnState;
     getCalculatedColumns(): CalculatedColumn[];
     getCalculatedColumnById(id: CalculatedColumn['Uuid']): CalculatedColumn;

package/src/Api/Implementation/CalculatedColumnApiImpl.js

@@ -3,9 +3,9 @@ import { ApiBase } from './ApiBase';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { CalculatedColumnInternalApi } from '../Internal/CalculatedColumnInternalApi';
 export class CalculatedColumnApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new CalculatedColumnInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new CalculatedColumnInternalApi(_adaptable);
     }
     getCalculatedColumnState() {
         return this.getAdaptableState().CalculatedColumn;

package/src/Api/Implementation/CalendarApiImpl.js

@@ -42,7 +42,7 @@ export class CalendarApiImpl extends ApiBase {
         const holidays = this.getCalendarOptions().holidays;
         if (holidays) {
             if (typeof holidays === 'function') {
-                return holidays(this.getAdaptableApi().internalApi.buildBaseContext());
+                return holidays(this.getAdaptableInternalApi().buildBaseContext());
             }
             else {
                 return holidays;

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

@@ -5,7 +5,7 @@ import { ChartContainer, ChartDefinition } from '../../types';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ExternalChartDefinition } from '../../PredefinedConfig/ChartingState';
 export declare class ChartingApiImpl extends ApiBase implements ChartingApi {
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     isChartingEnabled(): boolean;
     getCurrentChartModels(): ChartModel[];
     getChartRef(chartId: string): ChartRef;

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[];