@adaptabletools/adaptable 19.1.0-canary.0 → 19.1.1

package/src/Api/Implementation/GridApiImpl.js

@@ -7,12 +7,12 @@ import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { WINDOW_SHOW_TRANSPOSED_VIEW } from '../../View/Components/Popups/WindowPopups/windowFactory';
 import { ROW_SUMMARY_ROW_ID } from '../../PredefinedConfig/Common/RowSummary';
 export class GridApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new GridInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new GridInternalApi(_adaptable);
     }
     getVariant() {
-        return this.adaptable.variant;
+        return this.getAdaptableVariant();
     }
     getGridState() {
         return this.getAdaptableState().Grid;
@@ -22,20 +22,20 @@ export class GridApiImpl extends ApiBase {
         // to prevent `cellchanged` events from being triggered for rows that have
         // the same primary key with existing rows
         // see #testprevent_cellchanged_event_on_load_grid_data
-        this.adaptable.agGridAdapter.setGridOption('rowData', []);
-        this.adaptable.setGridData(dataSource);
+        this._adaptable.agGridAdapter.setGridOption('rowData', []);
+        this._adaptable.setGridData(dataSource);
         const allRowNodes = this.getAllRowNodes();
         this.internalApi.fireGridDataChangedEvent(dataSource, allRowNodes, 'Load');
     }
     getGridData() {
-        return this.adaptable.getGridData();
+        return this._adaptable.getGridData();
     }
     getFilteredData() {
-        return this.adaptable.getFilteredData();
+        return this._adaptable.getFilteredData();
     }
     getVisibleData() {
         const data = [];
-        this.adaptable.forAllVisibleRowNodesDo((rowNode) => {
+        this.getAdaptableInternalApi().forAllVisibleRowNodesDo((rowNode) => {
             if (!this.isGroupRowNode(rowNode)) {
                 data.push(rowNode.data);
             }
@@ -43,12 +43,12 @@ export class GridApiImpl extends ApiBase {
         return data;
     }
     async updateGridData(dataRows, dataUpdateConfig) {
-        const rowNodes = await this.adaptable.updateRows(dataRows, dataUpdateConfig);
+        const rowNodes = await this._adaptable.updateRows(dataRows, dataUpdateConfig);
         this.internalApi.fireGridDataChangedEvent(dataRows, rowNodes, 'Update');
         return rowNodes;
     }
     async addOrUpdateGridData(dataRows, dataUpdateConfig) {
-        const { added, updated } = await this.adaptable.addOrUpdateRows(dataRows, dataUpdateConfig);
+        const { added, updated } = await this._adaptable.addOrUpdateRows(dataRows, dataUpdateConfig);
         if (ArrayExtensions.IsNotNullOrEmpty(updated)) {
             this.internalApi.fireGridDataChangedEvent(dataRows, updated, 'Update');
         }
@@ -61,13 +61,13 @@ export class GridApiImpl extends ApiBase {
         };
     }
     async addGridData(dataRows, dataUpdateConfig) {
-        const rowNodes = await this.adaptable.addRows(dataRows, dataUpdateConfig);
+        const rowNodes = await this._adaptable.addRows(dataRows, dataUpdateConfig);
         this.internalApi.fireGridDataChangedEvent(dataRows, rowNodes, 'Add');
         return rowNodes;
     }
     undoCellEdit(cellDataChangedInfo) {
         // for the reason of this hacky solution see the comments in DataService
-        this.getAdaptableApi().internalApi.getDataService().logUndoChange(cellDataChangedInfo);
+        this.getAdaptableInternalApi().getDataService().logUndoChange(cellDataChangedInfo);
         const cellUpdateRequest = {
             columnId: cellDataChangedInfo.column.columnId,
             newValue: cellDataChangedInfo.oldValue,
@@ -79,7 +79,7 @@ export class GridApiImpl extends ApiBase {
     }
     async deleteGridData(dataRows, dataUpdateConfig) {
         if (this.checkArrayExists(dataRows)) {
-            const rowNodes = await this.adaptable.deleteRows(dataRows, dataUpdateConfig);
+            const rowNodes = await this._adaptable.deleteRows(dataRows, dataUpdateConfig);
             this.internalApi.fireGridDataChangedEvent(dataRows, rowNodes, 'Delete');
             return rowNodes;
         }
@@ -97,7 +97,7 @@ export class GridApiImpl extends ApiBase {
             this.logWarn(`setCellValue() - rowNode not found for primaryKeyValue: ${cellUpdateRequest.primaryKeyValue}`);
             return;
         }
-        this.adaptable.setDataValue(cellUpdateRequest.newValue, abColumn, cellUpdateRequest.primaryKeyValue, rowNode);
+        this._adaptable.setDataValue(cellUpdateRequest.newValue, abColumn, cellUpdateRequest.primaryKeyValue, rowNode);
         this.refreshCells([rowNode], [abColumn.columnId]);
     }
     setCellValues(cellUpdateRequests) {
@@ -122,10 +122,10 @@ export class GridApiImpl extends ApiBase {
         return rowNode ? this.getNormalisedValueFromRowNode(rowNode, columnId) : undefined;
     }
     hideFilterForm() {
-        this.adaptable.hideColumnFilterForm();
+        this._adaptable.hideColumnFilterForm();
     }
     applyGridFiltering() {
-        this.adaptable.applyColumnFiltering();
+        this._adaptable.applyColumnFiltering();
     }
     clearGridFiltering() {
         // slightly round the houses but we have to call ColumnFilterAPI as it does it properly
@@ -139,11 +139,11 @@ export class GridApiImpl extends ApiBase {
         return columnSorts === null || columnSorts === void 0 ? void 0 : columnSorts.find((cs) => cs.ColumnId == columnId);
     }
     setAdaptableSorting(columnSorts) {
-        this.adaptable.setColumnSort(columnSorts);
+        this._adaptable.setColumnSort(columnSorts);
         this.setColumnSorts(columnSorts);
     }
     clearAdaptableSorting() {
-        this.adaptable.clearColumnSort();
+        this._adaptable.clearColumnSort();
         this.clearColumnSorts();
     }
     setColumnSorts(columnSorts) {
@@ -163,13 +163,13 @@ export class GridApiImpl extends ApiBase {
         this.selectNodes(nodes, clearSelection);
     }
     selectNode(rowNode, clearSelection) {
-        this.adaptable.selectNode(rowNode, clearSelection);
+        this._adaptable.selectNode(rowNode, clearSelection);
     }
     selectNodes(rowNodes, clearSelection) {
-        this.adaptable.selectNodes(rowNodes, clearSelection);
+        this._adaptable.selectNodes(rowNodes, clearSelection);
     }
     deSelectRow(primaryKeyValue, clearSelection) {
-        this.adaptable.deSelectNode(this.getRowNodeForPrimaryKey(primaryKeyValue), clearSelection);
+        this._adaptable.deSelectNode(this.getRowNodeForPrimaryKey(primaryKeyValue), clearSelection);
     }
     deSelectRows(primaryKeyValues, clearSelection) {
         let nodes = [];
@@ -179,22 +179,22 @@ export class GridApiImpl extends ApiBase {
         this.deSelectNodes(nodes, clearSelection);
     }
     deSelectNode(rowNode, clearSelection) {
-        this.adaptable.deSelectNode(rowNode, clearSelection);
+        this._adaptable.deSelectNode(rowNode, clearSelection);
     }
     deSelectNodes(rowNodes, clearSelection) {
-        this.adaptable.deSelectNodes(rowNodes, clearSelection);
+        this._adaptable.deSelectNodes(rowNodes, clearSelection);
     }
     getSelectionStartEndNodes(gridCellRange) {
         let startNode;
         let endNode;
         startNode = gridCellRange.primaryKeyValueEnd
-            ? this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueStart)
-            : this.adaptable.getRowNodeByIndex(gridCellRange.rowIndexStart);
+            ? this._adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueStart)
+            : this._adaptable.getRowNodeByIndex(gridCellRange.rowIndexStart);
         if (gridCellRange.primaryKeyValueEnd) {
-            endNode = this.adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueEnd);
+            endNode = this._adaptable.getRowNodeForPrimaryKey(gridCellRange.primaryKeyValueEnd);
         }
         else if (gridCellRange.rowIndexEnd) {
-            endNode = this.adaptable.getRowNodeByIndex(gridCellRange.rowIndexEnd);
+            endNode = this._adaptable.getRowNodeByIndex(gridCellRange.rowIndexEnd);
         }
         else {
             endNode = startNode;
@@ -211,7 +211,7 @@ export class GridApiImpl extends ApiBase {
         }
         const [startNode, endNode] = this.getSelectionStartEndNodes(gridCellRange);
         if (startNode && endNode) {
-            this.adaptable.selectCells(gridCellRange.columnIds, startNode, endNode, clearSelection);
+            this._adaptable.selectCells(gridCellRange.columnIds, startNode, endNode, clearSelection);
         }
     }
     selectCellRangeByQuery(query, gridCellRange, clearSelection) {
@@ -222,13 +222,13 @@ export class GridApiImpl extends ApiBase {
         if (gridCellRange) {
             const [startNode, endNode] = this.getSelectionStartEndNodes(gridCellRange);
             for (let rowIndex = startNode.rowIndex; rowIndex <= endNode.rowIndex; rowIndex++) {
-                const rowNode = this.adaptable.getRowNodeByIndex(rowIndex);
+                const rowNode = this._adaptable.getRowNodeByIndex(rowIndex);
                 isRowNodeInQuery(rowNode) && filteredRowNodes.push(rowNode);
             }
         }
         else {
             // include all row
-            this.adaptable.forAllRowNodesDo((rowNode) => {
+            this._adaptable.forAllRowNodesDo((rowNode) => {
                 isRowNodeInQuery(rowNode) && filteredRowNodes.push(rowNode);
             });
         }
@@ -268,7 +268,7 @@ export class GridApiImpl extends ApiBase {
         let preparedClearSelection = clearSelection;
         rowRanges.forEach((range) => {
             // clear only on first range selection
-            this.adaptable.selectCells(preapredGridCellRange.columnIds, range.startNode, range.endNode, preparedClearSelection);
+            this._adaptable.selectCells(preapredGridCellRange.columnIds, range.startNode, range.endNode, preparedClearSelection);
             preparedClearSelection = false;
         });
     }
@@ -279,106 +279,106 @@ export class GridApiImpl extends ApiBase {
         this.getAdaptableApi().columnApi.selectColumns(columnIds);
     }
     getFirstRowNode() {
-        return this.adaptable.getFirstRowNode();
+        return this._adaptable.getFirstRowNode();
     }
     getFirstDisplayedRowNode() {
-        return this.adaptable.getFirstDisplayedRowNode();
+        return this._adaptable.getFirstDisplayedRowNode();
     }
     getVisibleRowNodes(config) {
         const rowNodes = [];
-        this.adaptable.forAllVisibleRowNodesDo((rowNode) => rowNodes.push(rowNode), config);
+        this.getAdaptableInternalApi().forAllVisibleRowNodesDo((rowNode) => rowNodes.push(rowNode), config);
         return rowNodes;
     }
     getAllRowNodes(config) {
-        return this.adaptable.getAllRowNodes(config);
+        return this._adaptable.getAllRowNodes(config);
     }
     getGroupRowNodes(config) {
-        return this.adaptable.getGroupRowNodes(config);
+        return this._adaptable.getGroupRowNodes(config);
     }
     getGridCellFromRowNode(rowNode, columnId) {
-        return this.adaptable.getGridCellFromRowNode(rowNode, columnId);
+        return this._adaptable.getGridCellFromRowNode(rowNode, columnId);
     }
     getRawValueFromRowNode(rowNode, columnId) {
-        return this.adaptable.getRawValueFromRowNode(rowNode, columnId);
+        return this._adaptable.getRawValueFromRowNode(rowNode, columnId);
     }
     getDisplayValueFromRowNode(rowNode, columnId) {
-        return this.adaptable.getDisplayValueFromRowNode(rowNode, columnId);
+        return this._adaptable.getDisplayValueFromRowNode(rowNode, columnId);
     }
     getDisplayValueFromRawValue(rowNode, columnId, rawValue) {
-        return this.adaptable.getDisplayValueFromRawValue(rowNode, columnId, rawValue);
+        return this._adaptable.getDisplayValueFromRawValue(rowNode, columnId, rawValue);
     }
     getNormalisedValueFromRowNode(rowNode, columnId) {
-        const rawValue = this.adaptable.getRawValueFromRowNode(rowNode, columnId);
+        const rawValue = this._adaptable.getRawValueFromRowNode(rowNode, columnId);
         const abColumn = this.getAdaptableApi().columnApi.getColumnWithColumnId(columnId);
-        return this.adaptable.getNormalisedValueFromRawValue(rawValue, abColumn);
+        return this._adaptable.getNormalisedValueFromRawValue(rawValue, abColumn);
     }
     getRowNodesForPrimaryKeys(primaryKeyValues) {
-        return this.adaptable.getRowNodesForPrimaryKeys(primaryKeyValues);
+        return this._adaptable.getRowNodesForPrimaryKeys(primaryKeyValues);
     }
     getRowNodeForPrimaryKey(primaryKeyValue) {
-        return this.adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
+        return this._adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
     }
     getPrimaryKeyValueForRowNode(rowNode) {
-        return this.adaptable.getPrimaryKeyValueFromRowNode(rowNode);
+        return this._adaptable.getPrimaryKeyValueFromRowNode(rowNode);
     }
     getRowNodeForIndex(index) {
-        return this.adaptable.getRowNodeByIndex(index);
+        return this._adaptable.getRowNodeByIndex(index);
     }
     getPrimaryKeyValuesForRowNodes(rowNodes) {
         return rowNodes.map((rowNode) => this.getPrimaryKeyValueForRowNode(rowNode));
     }
     setRowGroupColumns(columnIds) {
-        this.adaptable.setRowGroupColumns(columnIds);
+        this._adaptable.setRowGroupColumns(columnIds);
     }
     clearRowGroupColumns() {
-        this.adaptable.clearRowGroupColumns();
+        this._adaptable.clearRowGroupColumns();
     }
     expandAllRowGroups() {
-        this.adaptable.expandAllRowGroups();
+        this._adaptable.expandAllRowGroups();
     }
     collapseAllRowGroups() {
-        this.adaptable.collapseAllRowGroups();
+        this._adaptable.collapseAllRowGroups();
     }
     getExpandRowGroupsKeys() {
-        return this.adaptable.getExpandRowGroupsKeys();
+        return this._adaptable.getExpandRowGroupsKeys();
     }
     expandRowGroupsForValues(columnValues) {
-        this.adaptable.expandRowGroupsForValues(columnValues);
+        this._adaptable.expandRowGroupsForValues(columnValues);
     }
     isGridPivotable() {
-        return !this.getAdaptableApi().internalApi.isGridInTreeMode();
+        return !this.getAdaptableInternalApi().isGridInTreeMode();
     }
     isGridGroupable() {
-        return !this.getAdaptableApi().internalApi.isGridInTreeMode();
+        return !this.getAdaptableInternalApi().isGridInTreeMode();
     }
     isGridRowSelectable() {
-        return this.adaptable.isGridRowSelectable();
+        return this._adaptable.isGridRowSelectable();
     }
     isGridRangeSelectable() {
-        return this.adaptable.isGridRangeSelectable();
+        return this._adaptable.isGridRangeSelectable();
     }
     isGridRowGrouped() {
-        return this.adaptable.isGridGroupingActive();
+        return this._adaptable.isGridGroupingActive();
     }
     isGridInPivotMode() {
         return this.getLayoutApi().isCurrentLayoutPivot();
     }
     isGroupRowNode(rowNode) {
-        return this.adaptable.isGroupRowNode(rowNode);
+        return this._adaptable.isGroupRowNode(rowNode);
     }
     isSummaryNode(rowNode) {
         var _a;
         return !!((_a = rowNode === null || rowNode === void 0 ? void 0 : rowNode.data) === null || _a === void 0 ? void 0 : _a[ROW_SUMMARY_ROW_ID]);
     }
     isQuickFilterAvailable() {
-        return this.adaptable.isQuickFilterAvailable();
+        return this._adaptable.isQuickFilterAvailable();
     }
     redrawGrid() {
-        this.adaptable.redrawBody();
-        this.adaptable.refreshHeader();
+        this._adaptable.redrawBody();
+        this._adaptable.refreshHeader();
     }
     getGridCellsForRawValue(columnId, rawValue) {
-        const gridCells = this.adaptable.getGridCellsForColumn(columnId);
+        const gridCells = this._adaptable.getGridCellsForColumn(columnId);
         if (!gridCells) {
             return undefined;
         }
@@ -395,7 +395,7 @@ export class GridApiImpl extends ApiBase {
         return gridCells === null || gridCells === void 0 ? void 0 : gridCells.length;
     }
     getGridCellsForDisplayValue(columnId, displayValue) {
-        const gridCells = this.adaptable.getGridCellsForColumn(columnId);
+        const gridCells = this._adaptable.getGridCellsForColumn(columnId);
         if (!gridCells) {
             return undefined;
         }
@@ -408,15 +408,15 @@ export class GridApiImpl extends ApiBase {
         return returnGridCells;
     }
     jumpToRow(primaryKeyValue) {
-        const node = this.adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
-        this.adaptable.jumpToRow(node);
+        const node = this._adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
+        this._adaptable.jumpToRow(node);
     }
     jumpToColumn(columnId) {
-        this.adaptable.jumpToColumn(columnId);
+        this._adaptable.jumpToColumn(columnId);
     }
     jumpToCell(primaryKeyValue, columnId) {
-        const node = this.adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
-        this.adaptable.jumpToCell(columnId, node);
+        const node = this._adaptable.getRowNodeForPrimaryKey(primaryKeyValue);
+        this._adaptable.jumpToCell(columnId, node);
     }
     highlightCell(cellHighlightInfo) {
         this.dispatchAction(SystemHighlightCellAdd(cellHighlightInfo));
@@ -457,8 +457,11 @@ export class GridApiImpl extends ApiBase {
     unHighlightAllRows() {
         this.dispatchAction(SystemHighlightRowDeleteAll());
     }
-    refreshCells(rowNodes, columnIds) {
-        this.adaptable.refreshCells(rowNodes, columnIds, true);
+    refreshCells(rowNodes, columnIds, suppressFlash = true) {
+        this._adaptable.refreshCells(rowNodes, columnIds, suppressFlash);
+    }
+    refreshAllCells(forceUpdate = false) {
+        this._adaptable.refreshAllCells(forceUpdate);
     }
     refreshGridCell(gridCell) {
         this.refreshCells([gridCell.rowNode], [gridCell.column.columnId]);
@@ -469,25 +472,25 @@ export class GridApiImpl extends ApiBase {
         });
     }
     refreshColumn(columnId) {
-        this.adaptable.refreshCells(null, [columnId], true);
+        this._adaptable.refreshCells(null, [columnId], true);
     }
     refreshColumns(columnIds) {
-        this.adaptable.refreshCells(null, columnIds, true);
+        this._adaptable.refreshCells(null, columnIds, true);
     }
     refreshRowByPrimaryKey(primaryKey) {
         const rowNode = this.getRowNodeForPrimaryKey(primaryKey);
         this.refreshRowNode(rowNode);
     }
     refreshRowNode(rowNode) {
-        this.adaptable.redrawRow(rowNode);
+        this._adaptable.redrawRow(rowNode);
     }
     refreshRowNodes(rowNodes) {
-        this.adaptable.redrawRows(rowNodes);
+        this._adaptable.redrawRows(rowNodes);
     }
     refreshGroupRowNodes() {
         // see https://www.ag-grid.com/javascript-data-grid/client-side-row-stages/#refreshing-the-client-side-model
-        this.getAdaptableApi().agGridApi.refreshClientSideRowModel('group');
-        this.adaptable.updateRowGroupsExpandedState();
+        this.getAgGridApi().refreshClientSideRowModel('group');
+        this._adaptable.updateRowGroupsExpandedState();
     }
     isCellEditable(gridCell) {
         if (!gridCell) {
@@ -505,7 +508,7 @@ export class GridApiImpl extends ApiBase {
         }
         const cellEditableFn = this.getEditOptions().isCellEditable;
         if (cellEditableFn) {
-            const cellEditableContext = Object.assign({ gridCell }, this.getAdaptableApi().internalApi.buildBaseContext());
+            const cellEditableContext = Object.assign({ gridCell }, this.getAdaptableInternalApi().buildBaseContext());
             return cellEditableFn(cellEditableContext);
         }
         return true;
@@ -526,37 +529,37 @@ export class GridApiImpl extends ApiBase {
         return true;
     }
     getRowCount() {
-        return this.adaptable.getRowCount();
+        return this._adaptable.getRowCount();
     }
     getVisibleRowCount() {
-        return this.adaptable.getVisibleRowCount();
+        return this._adaptable.getVisibleRowCount();
     }
     getRowsInViewport() {
-        return this.adaptable.getRowsInViewport();
+        return this._adaptable.getRowsInViewport();
     }
     getColumnCount() {
-        return this.adaptable.getColumnCount();
+        return this._adaptable.getColumnCount();
     }
     getVisibleColumnCount() {
-        return this.adaptable.getVisibleColumnCount();
+        return this._adaptable.getVisibleColumnCount();
     }
     selectAll() {
-        this.adaptable.selectAll();
+        this._adaptable.selectAll();
     }
     deselectAll() {
-        this.adaptable.deselectAll();
+        this._adaptable.deselectAll();
     }
     destroy() {
-        this.adaptable.destroy();
+        this._adaptable.destroy();
     }
     getGridContainerElement() {
-        return this.adaptable.getAgGridContainerElement();
+        return this._adaptable.getAgGridContainerElement();
     }
     openGridInfoSettingsPanel() {
         this.showModulePopup(ModuleConstants.GridInfoModuleId);
     }
     getAgGridRowModelType() {
-        return this.adaptable.getAgGridRowModelType();
+        return this._adaptable.getAgGridRowModelType();
     }
     showTransposedView(transposeConfig = {}) {
         var _a, _b, _c, _d, _e;
@@ -565,7 +568,7 @@ export class GridApiImpl extends ApiBase {
         const visibleColumns = (_c = transposeConfig.visibleColumns) !== null && _c !== void 0 ? _c : false;
         const visibleRows = (_d = transposeConfig.visibleRows) !== null && _d !== void 0 ? _d : false;
         const autosize = (_e = transposeConfig.autosize) !== null && _e !== void 0 ? _e : true;
-        this.getAdaptableApi().internalApi.showPopupWindow({
+        this.getAdaptableInternalApi().showPopupWindow({
             id: WINDOW_SHOW_TRANSPOSED_VIEW,
             factoryId: WINDOW_SHOW_TRANSPOSED_VIEW,
             title: 'Transposed View',
@@ -580,7 +583,7 @@ export class GridApiImpl extends ApiBase {
         });
     }
     getAllAgGridColumns() {
-        return this.adaptable.getAllGridColumns();
+        return this._adaptable.getAllGridColumns();
     }
     updateAgGridColumnState(columnState) {
         const columnExists = this.getColumnApi().doesColumnExist(columnState.colId);
@@ -588,7 +591,7 @@ export class GridApiImpl extends ApiBase {
             this.logWarn(`Column with id ${columnState.colId} does not exist, could NOT update configuration`);
             return;
         }
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        const agGridApi = this._adaptable.agGridAdapter.getAgGridApi();
         agGridApi.applyColumnState({
             state: [columnState],
         });
@@ -601,18 +604,18 @@ export class GridApiImpl extends ApiBase {
         notExistingColumnIds.forEach((colId) => {
             this.logWarn(`Column with id ${colId} does not exist, could NOT update configuration`);
         });
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        const agGridApi = this._adaptable.agGridAdapter.getAgGridApi();
         agGridApi.applyColumnState({
             state: existingColumnStates,
         });
     }
     setAgGridColumnDefinitions(columnDefinitions) {
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        const agGridApi = this._adaptable.agGridAdapter.getAgGridApi();
         agGridApi.setGridOption('columnDefs', columnDefinitions);
-        this.adaptable.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
+        this._adaptable.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
     }
     updateAgGridColumnDefinition(columnDefinitionToBeUpdated) {
-        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const currentColDefs = [...this._adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
         const columnId = columnDefinitionToBeUpdated.colId;
         const doesColumnExist = this.getColumnApi().doesColumnExist(columnId);
         if (!doesColumnExist) {
@@ -621,20 +624,20 @@ export class GridApiImpl extends ApiBase {
             this.setAgGridColumnDefinitions(newColDefs);
             return;
         }
-        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+        const updatedColDefs = this._adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
             return colDef.colId === columnId ? Object.assign(Object.assign({}, colDef), columnDefinitionToBeUpdated) : colDef;
         });
         this.setAgGridColumnDefinitions(updatedColDefs);
     }
     updateAgGridColumnDefinitions(columnDefinitionsToBeUpdated) {
-        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
-        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+        const currentColDefs = [...this._adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const updatedColDefs = this._adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
             const newColDef = newColumnDefinitions.find((c) => c.colId === colDef.colId);
             return newColDef ? Object.assign(Object.assign({}, colDef), newColDef) : colDef;
         });
         // find out new columns which are not in the current column definitions
         const currentColIds = [];
-        this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+        this._adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
             currentColIds.push(colDef.colId);
             return colDef;
         });
@@ -650,8 +653,8 @@ export class GridApiImpl extends ApiBase {
             this.logWarn(`Column with id ${columnId} does not exist!`);
             return;
         }
-        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
-        const updatedColDefs = this.adaptable.agGridAdapter
+        const currentColDefs = this._adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        const updatedColDefs = this._adaptable.agGridAdapter
             .traverseColDefs(currentColDefs, (colDef) => {
             return colDef.colId === columnId ? null : colDef;
         })
@@ -659,9 +662,9 @@ export class GridApiImpl extends ApiBase {
         this.setAgGridColumnDefinitions(updatedColDefs);
     }
     addAgGridColumnDefinition(newColumnDefinition) {
-        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        const currentColDefs = this._adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
         // just in case check of there is not already an existing column with the same id and eliminate it
-        const sanitizedColDefs = this.adaptable.agGridAdapter
+        const sanitizedColDefs = this._adaptable.agGridAdapter
             .traverseColDefs(currentColDefs, (colDef) => {
             return colDef.colId === newColumnDefinition.colId ? null : colDef;
         })

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

@@ -5,7 +5,7 @@ import { ApiBase } from './ApiBase';
 import { GridFilter } from '../../types';
 export declare class GridFilterApiImpl extends ApiBase implements GridFilterApi {
     internalApi: GridFilterInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     getCurrentGridFilter(): GridFilter | undefined;
     getCurrentGridFilterExpression(): string | undefined;
     setGridFilterExpression(filter: string): void;

package/src/Api/Implementation/GridFilterApiImpl.js

@@ -4,9 +4,9 @@ import { GridFilterInternalApi } from '../Internal/GridFilterInternalApi';
 import { ApiBase } from './ApiBase';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 export class GridFilterApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new GridFilterInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new GridFilterInternalApi(_adaptable);
     }
     getCurrentGridFilter() {
         var _a;
@@ -24,7 +24,7 @@ export class GridFilterApiImpl extends ApiBase {
     }
     openUIEditorForGridFilter(expression) {
         const preparedQuery = expression !== null && expression !== void 0 ? expression : this.getCurrentGridFilterExpression();
-        this.getAdaptableApi().internalApi.showPopupWindow({
+        this.getAdaptableInternalApi().showPopupWindow({
             id: WINDOW_GRID_FILTER_EDITOR,
             title: ModuleConstants.GridFilterFriendlyName,
             icon: 'filter-list',

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

@@ -9,7 +9,7 @@ import { LayoutInternalApi } from '../Internal/LayoutInternalApi';
 import { ExtendedLayoutInfo } from '../../PredefinedConfig/Common/ExtendedLayoutInfo';
 export declare class LayoutApiImpl extends ApiBase implements LayoutApi {
     internalApi: LayoutInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     isCurrentLayoutPivot(): boolean;
     getLayoutState(): LayoutState;
     shouldAutoSaveLayouts: () => boolean;

package/src/Api/Implementation/LayoutApiImpl.js

@@ -10,13 +10,13 @@ import { DEFAULT_LAYOUT } from '../../Utilities/Constants/GeneralConstants';
 import { PopupShowPrompt } from '../../Redux/ActionsReducers/PopupRedux';
 import { LayoutInternalApi } from '../Internal/LayoutInternalApi';
 export class LayoutApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
         this.shouldAutoSaveLayouts = () => {
             var _a;
             return (_a = this.getLayoutOptions()) === null || _a === void 0 ? void 0 : _a.autoSaveLayouts;
         };
-        this.internalApi = new LayoutInternalApi(adaptable);
+        this.internalApi = new LayoutInternalApi(_adaptable);
     }
     isCurrentLayoutPivot() {
         return this.getCurrentLayout().EnablePivot;

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

@@ -5,7 +5,7 @@ import { NamedQueryApi, NamedQueryValidationResult } from '../NamedQueryApi';
 import { ApiBase } from './ApiBase';
 export declare class NamedQueryApiImpl extends ApiBase implements NamedQueryApi {
     internalApi: NamedQueryInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     addNamedQuery(namedQuery: NamedQuery): void;
     addNamedQueries(namedQueries: NamedQuery[]): void;
     getNamedQueryState(): NamedQueryState;

package/src/Api/Implementation/NamedQueryApiImpl.js

@@ -4,9 +4,9 @@ import { NamedQueryInternalApi } from '../Internal/NamedQueryInternalApi';
 import { ApiBase } from './ApiBase';
 import * as NamedQueryRedux from '../../Redux/ActionsReducers/NamedQueryRedux';
 export class NamedQueryApiImpl extends ApiBase {
-    constructor(adaptable) {
-        super(adaptable);
-        this.internalApi = new NamedQueryInternalApi(adaptable);
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new NamedQueryInternalApi(_adaptable);
     }
     addNamedQuery(namedQuery) {
         this.dispatchAction(NamedQueryRedux.NamedQueryAdd(namedQuery));

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

@@ -6,7 +6,7 @@ import { NoteInternalApi } from '../Internal/NoteInternalApi';
 import { CellAddress } from '../../types';
 export declare class NoteApiImpl extends ApiBase implements NoteApi {
     internalApi: NoteInternalApi;
-    constructor(adaptable: IAdaptable);
+    constructor(_adaptable: IAdaptable);
     addNote(noteStr: string, primaryKeyValue: any, columnId: string): void;
     editNote(note: AdaptableNote): void;
     updateNoteText(noteStr: string, note: AdaptableNote): void;