@adaptabletools/adaptable 19.1.0 → 19.1.2-canary.0

package/package.json

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

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { ChartModel, ChartRef, Column, GridApi, GridOptions, IRowNode, Module, RowModelType, StatusPanelDef } from '@ag-grid-community/core';
-import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableApi, DestroyConfig } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { ColumnSort } from '../PredefinedConfig/Common/ColumnSort';
 import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
@@ -262,10 +262,7 @@ export interface IAdaptable {
     getAgGridColumnForColumnId(columnId: string): Column;
     getMinMaxCachedValueForColumn(column: AdaptableColumn, minMax: 'min' | 'max'): number | undefined;
     getAgGridRegisteredModules(): Module[];
-    destroy(config?: {
-        unmount: boolean;
-        destroyApi?: boolean;
-    }): void;
+    destroy(config?: DestroyConfig): void;
     setLayout(layout?: Layout): void;
     canExportToExcel(): boolean;
     exportToExcel(reportData: ReportData, fileName: string): void;

package/src/AdaptableOptions/AlertOptions.d.ts

@@ -68,6 +68,9 @@ export interface AlertOptions<TData = any> {
      */
     showMissingPrimaryKeyAlert?: boolean;
 }
+/**
+ * Cell Change that will trigger an Alert: can be 'rawValue' or 'formattedValue'
+ */
 export type DataChangeDetectionPolicy = 'rawValue' | 'formattedValue';
 /**
  * Handles a Form Button Action

package/src/AdaptableOptions/ColumnMenuOptions.d.ts

@@ -91,4 +91,4 @@ export interface UserColumnMenuItem {
 /**
  * Defines AG Grid Column Menu Items
  */
-export type AgGridColumnMenuItemType = 'pinSubMenu' | 'valueAggSubMenu' | 'autoSizeThis' | 'autoSizeAll' | 'rowGroup' | 'rowUnGroup' | 'resetColumns' | 'expandAll' | 'contractAll' | 'separator';
+export type AgGridColumnMenuItemType = 'sortAscending' | 'sortDescending' | 'sortUnSort' | 'columnFilter' | 'columnChooser' | 'pinSubMenu' | 'valueAggSubMenu' | 'autoSizeThis' | 'autoSizeAll' | 'rowGroup' | 'rowUnGroup' | 'resetColumns' | 'expandAll' | 'contractAll' | 'separator';

package/src/AdaptableOptions/CommentOptions.d.ts

@@ -17,11 +17,11 @@ export interface CommentOptions<TData = any> {
      */
     persistCommentThreads?(commentThreads: CommentThread[]): Promise<void>;
     /**
-     * Format string for dates in Comments Popup
+     * Format string for Dates in Comments Popup
      *
      * @defaultValue 'dd-MM-yyyy HH:mm:ss'
      */
-    dateFormat?: string;
+    dateFormat?: string | (() => string);
     /**
      * Show the Close Button in the Comments Popup
      * @defaultValue true

package/src/AdaptableOptions/NoteOptions.d.ts

@@ -8,11 +8,11 @@ export interface NoteOptions<TData = any> {
      */
     isCellNotable?: (context: NotableCellContext) => boolean;
     /**
-     * Format string for formatting in the Notes Popup
+     * Format string for Dates in Notes Popup
      *
      * @defaultValue 'dd-MM-yyyy HH:mm:ss'
      */
-    dateFormat?: string;
+    dateFormat?: string | (() => string);
     /**
      * Show the Close Button in the Notes Popup
      *

package/src/Api/AdaptableApi.d.ts

@@ -258,23 +258,33 @@ export interface AdaptableApi {
      */
     gridFilterApi: GridFilterApi;
     /**
-     * Cleanup method - should be called only when using the vanilla javascript component, as framework components cleanup is performed when the component is destroyed/unmounted.
-     * This destroys the Adaptable instance.
+     * Cleanup method - call only for vanilla JavaScript components, as framework components handle cleanup on destroy/unmount. By default, it unmounts the Adaptable component and destroys the AG Grid instance.
+     * @param config - optional configuration object
      */
-    destroy: (config?: {
-        unmount: boolean;
-        destroyApi?: boolean;
-    }) => void;
+    destroy: (config?: DestroyConfig) => void;
     /**
      * Whether the Adaptable instance has been destroyed
      */
     isDestroyed: () => boolean;
+}
+/**
+ * Adaptable Destroy Configuration
+ */
+export interface DestroyConfig {
+    /**
+     * Unmount the Adaptable component (Dashboard)
+     *
+     * @defaultValue true
+     */
+    unmount: boolean;
+    /**
+     * @deprecated use `destroyAgGrid` instead
+     */
+    destroyApi?: boolean;
     /**
-     * Cleanup method that only cleans up this api instance (clears event listeners and sets every property to null), but does not destroy the Adaptable instance.
+     * Destroy the AgGrid instance
      *
+     * @defaultValue true
      */
-    internalDestroySelf: (config?: {
-        unmount: boolean;
-        destroyApi?: boolean;
-    }) => void;
+    destroyAgGrid: boolean;
 }

package/src/Api/Events/GridDataChanged.d.ts

@@ -1,5 +1,8 @@
 import { IRowNode } from '@ag-grid-community/core';
 import { BaseEventInfo } from './BaseEventInfo';
+/**
+ * What row action triggered the Grid change: 'Add', 'Update', 'Delete' or 'Load'
+ */
 export type GridDataChangeTrigger = 'Add' | 'Update' | 'Delete' | 'Load';
 /**
  * EventInfo returned by GridDataChanged event

package/src/Api/GridApi.d.ts

@@ -456,7 +456,12 @@ 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;
+    /**
+     * Refreshes all Cells in the Grid
+     * @param forceUpdate forces AG Grid change detection
+     */
+    refreshAllCells(forceUpdate?: boolean): void;
     /**
      * Refreshes a single Grid Cell
      * @param gridCell GridCell to refresh
@@ -468,7 +473,7 @@ export interface GridApi {
      */
     refreshGridCells(gridCells: GridCell[]): void;
     /**
-     * Forces a re-render of the row with the given primary key value
+     * Forces a re-render of Row with given Primary Key value
      * @param primaryKey row primary key
      */
     refreshRowByPrimaryKey(primaryKey: any): void;
@@ -503,7 +508,7 @@ export interface GridApi {
      */
     getVisibleColumnCount(): number;
     /**
-     * Destroys current AdapTable instance
+     * @deprecated use `AdaptableApi.destroy()` instead
      */
     destroy(): void;
     /**

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

@@ -1,6 +1,6 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableInternalApi } from '../Internal/AdaptableInternalApi';
-import { AdaptableApi, ColumnMenuApi, ContextMenuApi, DataImportApi, NamedQueryApi, OptionsApi, SettingsPanelApi } from '../../types';
+import { AdaptableApi, ColumnMenuApi, ContextMenuApi, DataImportApi, DestroyConfig, NamedQueryApi, OptionsApi, SettingsPanelApi } from '../../types';
 import { AlertApi } from '../AlertApi';
 import { BulkUpdateApi } from '../BulkUpdateApi';
 import { CalendarApi } from '../CalendarApi';
@@ -104,16 +104,15 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     /**
      * This is only meant to be called by the Adaptable instance.
      */
-    internalDestroySelf(): void;
-    destroy(config?: {
-        unmount: boolean;
-        destroyApi?: boolean;
-    }): void;
+    _internalDestroySelf(): void;
+    destroy(config?: DestroyConfig): 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

@@ -113,7 +113,7 @@ export class AdaptableApiImpl {
     /**
      * This is only meant to be called by the Adaptable instance.
      */
-    internalDestroySelf() {
+    _internalDestroySelf() {
         if (this.destroyed) {
             return;
         }
@@ -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;