@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.0

package/src/Api/GridApi.d.ts

@@ -1,4 +1,3 @@
-import { GridState } from '../PredefinedConfig/GridState';
 import { SelectedCellInfo } from '../PredefinedConfig/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../PredefinedConfig/Selection/SelectedRowInfo';
 import { ColumnSort } from '../PredefinedConfig/Common/ColumnSort';
@@ -7,20 +6,25 @@ import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
 import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { CellHighlightInfo } from '../PredefinedConfig/Common/CellHighlightInfo';
 import { RowHighlightInfo } from '../PredefinedConfig/Common/RowHighlightInfo';
-import { ColDef, ColGroupDef, Column, ColumnState, IRowNode, RowModelType } from '@ag-grid-community/core';
+import { CellSummmaryInfo } from '../PredefinedConfig/Common/CellSummary';
+import { ColDef, ColGroupDef, Column, ColumnState, IRowNode, RowModelType } from 'ag-grid-enterprise';
 import { GridCellRange } from '../PredefinedConfig/Selection/GridCellRange';
 import { RowsHighlightInfo } from '../PredefinedConfig/Common/RowsHighlightInfo';
 import { TransposeConfig } from '../PredefinedConfig/Common/TransposeConfig';
 import { AdaptableVariant } from '../AdaptableInterfaces/IAdaptable';
+import { InternalState } from '../PredefinedConfig/InternalState';
 /**
  * Provides access to important properties and functionalities of AdapTable e.g. sorting, selected cells etc.
  */
 export interface GridApi {
+    /**
+     * Returns current AdapTable Variant: vanilla, angular, react, vue
+     */
     getVariant(): AdaptableVariant;
     /**
-     * Returns Grid section from AdapTable State
+     * Returns the Internal section from AdapTable State
      */
-    getGridState(): GridState;
+    getInternalState(): InternalState;
     /**
      * Retrieves all data from the grid
      */
@@ -34,7 +38,7 @@ export interface GridApi {
      */
     getVisibleData(): any[];
     /**
-     * Loads data into grid and fire a `GridDataChanged.trigger='Load'` event
+     * Loads data into grid and fire a `RowChanged.trigger='Load'` event
      * @param data data to load
      */
     loadGridData(data: any): void;
@@ -80,6 +84,10 @@ export interface GridApi {
      * @param cellDataChangedInfo data change to undo
      */
     undoCellEdit(cellDataChangedInfo: CellDataChangedInfo): boolean;
+    /**
+     * Returns summary info on Selected Cells
+     */
+    getCellSummaryInfo(): CellSummmaryInfo;
     /**
      * Returns all current Selected Cells in AdapTable
      */
@@ -98,22 +106,13 @@ export interface GridApi {
      */
     getColumnSortForColumn(columnId: string): ColumnSort | undefined;
     /**
-     * Sets Column Sorts in Grid
-     * @param columnSorts Column Sorts to set
-     */
-    setColumnSorts(columnSorts: ColumnSort[]): void;
-    /**
-     * Hides the AdapTable Filter Form
+     * Applies current Filtering in AdapTable
      */
-    hideFilterForm(): void;
+    applyFiltering(): void;
     /**
-     * Applies current Filtering and Searching in AdapTable
+     * Removes all current Filters in AdapTable
      */
-    applyGridFiltering(): void;
-    /**
-     * Removes all current Filters and Searches in AdapTable
-     */
-    clearGridFiltering(): void;
+    clearFiltering(): void;
     /**
      * Sorts AdapTable using given Column Sorts
      * @param columnSorts Column Sorts to use
@@ -335,10 +334,6 @@ export interface GridApi {
      * Collapse all open groups in Row Grouping
      */
     collapseAllRowGroups(): void;
-    /**
-     * Get keys for any open rows in Row Grouping
-     */
-    getExpandRowGroupsKeys(): any[];
     /**
      * Expands Row Groups that contain given keys
      * @param columnValues values to open Row Groups for
@@ -356,6 +351,11 @@ export interface GridApi {
      * Whether AdapTable instance offers row selection
      */
     isGridRowSelectable(): boolean;
+    /**
+     * Whether a Row is selected
+     * @param primaryKeyValue pkVaue of Row to check
+     */
+    isGridRowSelected(primaryKeyValue: any): boolean;
     /**
      * Whether AdapTable instance offers cell range selection
      */
@@ -368,13 +368,26 @@ export interface GridApi {
      * Whether Grid is currently in Pivot Mode
      */
     isGridInPivotMode(): boolean;
+    /**
+     * Whether Grid displays a Tree Data  (structured hierarchical data)
+     */
+    isTreeDataGrid(): boolean;
+    /**
+     * Whether Grid is a Master Detail Grid
+     */
+    isMasterDetailGrid(): boolean;
     /**
      * Whether given Row Node is a Row Group
      * @param rowNode Node to check
      */
     isGroupRowNode(rowNode: IRowNode): boolean;
     /**
-     * Whether given Row Node is in a Smmary Row
+     * Whether given Row Node is visible
+     * @param rowNode Node to check
+     */
+    isVisibleRowNode(rowNode: IRowNode): boolean;
+    /**
+     * Whether given Row Node is in a Summary Row
      * @param rowNode Node to check
      */
     isSummaryNode(rowNode: IRowNode): boolean;
@@ -400,8 +413,9 @@ export interface GridApi {
      * Grid will jump to cell in a given Row and Column
      * @param primaryKeyValue value in Primary Key Column
      * @param columnId Id of Column
+     * @param rowNode AG Grid RowNode
      */
-    jumpToCell(primaryKeyValue: any, columnId: string): void;
+    jumpToCell(primaryKeyValue: any, columnId: string, rowNode?: IRowNode): void;
     /**
      * Highlights a Cell in AdapTable
      * @param cellHighlightInfo cell to highlight
@@ -451,12 +465,18 @@ export interface GridApi {
      * @param columnIds - the IDs of the Columns to refresh
      */
     refreshColumns(columnIds: string[]): void;
+    /**
+     * Refresh a Cell Value in AdapTable
+     * @param rowNode AG Grid RowNode which contains cell to refresh
+     * @param columnId ColumnId which contains cell to refresh
+     */
+    refreshCell(rowNode: IRowNode, columnId: string, suppressFlash?: boolean): void;
     /**
      * Refresh Cell Values in AdapTable
-     * @param rowNodes agGrid RowNodes which contain cells to refresh
+     * @param rowNode agGrid RowNode which contains cells to refresh
      * @param columnIds ColumnIds which contain cells to refresh
      */
-    refreshCells(rowNodes: IRowNode[], columnIds: string[], suppressFlash?: boolean): void;
+    refreshCells(rowNode: IRowNode, columnIds: string[], suppressFlash?: boolean): void;
     /**
      * Refreshes all Cells in the Grid
      * @param forceUpdate forces AG Grid change detection
@@ -468,7 +488,7 @@ export interface GridApi {
      */
     refreshGridCell(gridCell: GridCell): void;
     /**
-     * Refreshes a single Grid Cell
+     * Refreshes a set of Grid Cells
      * @param gridCells GridCells to refresh
      */
     refreshGridCells(gridCells: GridCell[]): void;
@@ -507,10 +527,6 @@ export interface GridApi {
      * Returns number of visible columns in Data Source
      */
     getVisibleColumnCount(): number;
-    /**
-     * @deprecated use `AdaptableApi.destroy()` instead
-     */
-    destroy(): void;
     /**
      * Checks if given Grid Cell is editable
      * @param gridCell Cell to check
@@ -555,12 +571,12 @@ export interface GridApi {
      */
     getAllAgGridColumns(): Column<any>[];
     /**
-     * Updates Column State for a given Column; Column State is stateful information and represents changing values of the grid. AdapTable will update the current Layout with the new state.
+     * Updates Ag Grid Column State for a given Column; use to update STATEFUL AG Grid Column props
      * @param columnState - the AG Grid ColumnState to set
      */
     updateAgGridColumnState(columnState: ColumnState): void;
     /**
-     * Updates Column State for given Columns; Column State is stateful information and represents changing values of the grid. AdapTable will update the current Layout with the new state.
+     * Updates Ag Grid Column State for given Columns; use to update STATEFUL AG Grid Column props
      * @param columnStates - the AG Grid ColumnState to set
      */
     updateAgGridColumnStates(columnStates: ColumnState[]): void;
@@ -569,13 +585,13 @@ export interface GridApi {
      */
     setAgGridColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
     /**
-     * Updates the Column Definition for a given Column. The provided column properties are merged with the existing Column Definition.
+     * Updates Column Definition for given Column; use to update NON-STATEFUL AG Grid Column props (which are merged with existing Column Def)
      * @param columnId - the ColumnId to update
      * @param columnDefinition - the new Column Definition
      */
     updateAgGridColumnDefinition(columnDefinition: ColDefWithId): void;
     /**
-     * Updates the Column Definitions for the given Columns. The provided column properties are merged with the existing Column Definitions.
+     * Updates Column Definition for given Columns; use to update NON-STATEFUL AG Grid Column props (which are merged with existing Column Def)
      * @param columnId - the ColumnId to update
      * @param columnDefinition - the new Column Definition
      */

package/src/Api/GridFilterApi.d.ts

@@ -4,7 +4,7 @@ import { GridFilter } from '../types';
  */
 export interface GridFilterApi {
     /**
-     *  Retrieves the Grid Filter from the current Layout
+     * Retrieves the Grid Filter from the current Layout
      * @returns Grid Filter
      */
     getCurrentGridFilter(): GridFilter | undefined;
@@ -24,7 +24,6 @@ export interface GridFilterApi {
     clearGridFilter(): void;
     /**
      * Opens the AdapTableQL UI Components (Expression Editor & Query Builder)
-     *
      * @param expression current Grid Filter expression
      */
     openUIEditorForGridFilter(expression?: string): void;

package/src/Api/IPushPullApi.d.ts

@@ -1,4 +1,4 @@
-import { IPushPullReport } from '../PredefinedConfig/SystemState';
+import { IPushPullReport } from '../PredefinedConfig/InternalState';
 import { IPushPullDomain, IPushPullSchedule } from '../PredefinedConfig/IPushPullState';
 /**
  * Provides run-time access to ipushpull Plugin

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

@@ -1,7 +1,10 @@
 import { ActionColumn, ActionColumnApi } from '../../../types';
 import { ApiBase } from './ApiBase';
-import { ColDef } from '@ag-grid-community/core';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { ActionColumnInternalApi } from '../Internal/ActionColumnInternalApi';
 export declare class ActionColumnApiImpl extends ApiBase implements ActionColumnApi {
+    internalApi: ActionColumnInternalApi;
+    constructor(_adaptable: IAdaptable);
     getActionColumns(): ActionColumn[];
-    getColDefsForActionColumns(): ColDef[];
+    getActionColumnForColumnId(columnId: string): ActionColumn | undefined;
 }

package/src/Api/Implementation/ActionColumnApiImpl.js

@@ -1,37 +1,14 @@
 import { ApiBase } from './ApiBase';
-import { ActionColumnRenderer, ReactActionColumnRenderer } from '../../agGrid/ActionColumnRenderer';
-import { AB_SPECIAL_COLUMN } from '../../Utilities/Constants/GeneralConstants';
+import { ActionColumnInternalApi } from '../Internal/ActionColumnInternalApi';
 export class ActionColumnApiImpl extends ApiBase {
+    constructor(_adaptable) {
+        super(_adaptable);
+        this.internalApi = new ActionColumnInternalApi(_adaptable);
+    }
     getActionColumns() {
-        var _a;
-        return (_a = this.getActionColumnOptions().actionColumns) !== null && _a !== void 0 ? _a : [];
+        return this.getActionColumnOptions().actionColumns ?? [];
     }
-    getColDefsForActionColumns() {
-        const defaultSpecialColumnSettings = this.getGridApi().internalApi.deriveSpecialColumnSettingsFromAgGridDefaultColDef();
-        const defaultActionColumnSettings = Object.assign(Object.assign({}, defaultSpecialColumnSettings), { resizable: true, suppressMenu: false, suppressMovable: false });
-        return this.getActionColumnApi()
-            .getActionColumns()
-            .map((actionColumn) => {
-            const actionColumnSettings = Object.assign(Object.assign({}, defaultActionColumnSettings), actionColumn.actionColumnSettings);
-            const newColDef = {
-                headerName: actionColumn.friendlyName ? actionColumn.friendlyName : actionColumn.columnId,
-                colId: actionColumn.columnId,
-                hide: false,
-                editable: false,
-                width: actionColumnSettings.width,
-                resizable: actionColumnSettings.resizable,
-                suppressHeaderMenuButton: actionColumnSettings.suppressMenu,
-                suppressMovable: actionColumnSettings.suppressMovable,
-                filter: false,
-                sortable: false,
-                enableRowGroup: false,
-                cellRenderer: this.getGridApi().getVariant() === 'react'
-                    ? ReactActionColumnRenderer
-                    : ActionColumnRenderer,
-                type: [AB_SPECIAL_COLUMN, 'abColDefObject'],
-            };
-            this.getAdaptableApi().logInfo('Setting up Action Column: ' + actionColumn.columnId);
-            return newColDef;
-        });
+    getActionColumnForColumnId(columnId) {
+        return this.getActionColumns().find((ac) => ac.columnId === columnId);
     }
 }

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, DestroyConfig, NamedQueryApi, OptionsApi, SettingsPanelApi } from '../../types';
+import { AdaptableApi, ColumnMenuApi, ContextMenuApi, DataImportApi, DestroyConfig, FilterApi, NamedQueryApi, OptionsApi, SettingsPanelApi } from '../../types';
 import { AlertApi } from '../AlertApi';
 import { BulkUpdateApi } from '../BulkUpdateApi';
 import { CalendarApi } from '../CalendarApi';
@@ -39,18 +39,15 @@ import { ChartingApi } from '../ChartingApi';
 import { StatusBarApi } from '../StatusBarApi';
 import { StyledColumnApi } from '../StyledColumnApi';
 import { ActionColumnApi } from '../ActionColumnApi';
-import { ActionRowApi } from '../ActionRowApi';
 import { NoteApi } from '../NoteApi';
 import { Fdc3Api } from '../Fdc3Api';
-import { GridFilterApi } from '../GridFilterApi';
-import { ColumnFilterApi } from '../ColumnFilterApi';
 import { CommentApi } from '../CommentApi';
+import { RowFormApi } from '../RowFormApi';
 export declare class AdaptableApiImpl implements AdaptableApi {
     protected adaptable: IAdaptable;
     internalApi: AdaptableInternalApi;
     optionsApi: OptionsApi;
     actionColumnApi: ActionColumnApi;
-    actionRowApi: ActionRowApi;
     applicationApi: ApplicationApi;
     alertApi: AlertApi;
     flashingCellApi: FlashingCellApi;
@@ -73,10 +70,11 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     layoutApi: LayoutApi;
     plusMinusApi: PlusMinusApi;
     quickSearchApi: QuickSearchApi;
+    rowFormApi: RowFormApi;
     scheduleApi: ScheduleApi;
     shortcutApi: ShortcutApi;
     smartEditApi: SmartEditApi;
-    columnFilterApi: ColumnFilterApi;
+    filterApi: FilterApi;
     systemStatusApi: SystemStatusApi;
     pluginsApi: PluginsApi;
     themeApi: ThemeApi;
@@ -95,12 +93,11 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     contextMenuApi: ContextMenuApi;
     fdc3Api: Fdc3Api;
     dataImportApi: DataImportApi;
-    gridFilterApi: GridFilterApi;
     namedQueryApi: NamedQueryApi;
     commentApi: CommentApi;
     private destroyed;
     constructor(adaptable: IAdaptable);
-    get agGridApi(): import("@ag-grid-community/core/dist/types/src/api/gridApi").GridApi<any>;
+    get agGridApi(): import("ag-grid-community").GridApi<any>;
     /**
      * This is only meant to be called by the Adaptable instance.
      */

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -35,7 +35,6 @@ import { FlashingCellApiImpl } from './FlashingCellApiImpl';
 import { ChartingApiImpl } from './ChartingApiImpl';
 import { SettingsPanelApiImpl } from './SettingsPanelApiImpl';
 import { ActionColumnApiImpl } from './ActionColumnApiImpl';
-import { ActionRowApiImpl } from './ActionRowApiImpl';
 import { StyledColumnApiImpl } from './StyledColumnApiImpl';
 import { CalendarApiImpl } from './CalendarApiImpl';
 import { EntitlementApiImpl } from './EntitlementApiImpl';
@@ -43,12 +42,12 @@ import { OptionsApiImpl } from './OptionsApiImpl';
 import { NoteApiImpl } from './NoteApiImpl';
 import { Fdc3ApiImpl } from './Fdc3ApiImpl';
 import { DataImportApiImpl } from './DataImportApiImpl';
-import { GridFilterApiImpl } from './GridFilterApiImpl';
 import { NamedQueryApiImpl } from './NamedQueryApiImpl';
-import { ColumnFilterApiImpl } from './ColumnFilterApiImpl';
 import { CommentsApiImpl } from './CommentsApiImpl';
 import { ColumnMenuApiImpl } from './ColumnMenuApiImpl';
 import { ContextMenuApiImpl } from './ContextMenuApiImpl';
+import { FilterApiImpl } from './FilterApiImpl';
+import { RowFormApiImpl } from './RowFormApiImpl';
 export class AdaptableApiImpl {
     constructor(adaptable) {
         this.adaptable = adaptable;
@@ -56,7 +55,6 @@ export class AdaptableApiImpl {
         this.adaptable = adaptable;
         this.optionsApi = new OptionsApiImpl(adaptable);
         this.actionColumnApi = new ActionColumnApiImpl(adaptable);
-        this.actionRowApi = new ActionRowApiImpl(adaptable);
         this.applicationApi = new ApplicationApiImpl(adaptable);
         this.alertApi = new AlertApiImpl(adaptable);
         this.flashingCellApi = new FlashingCellApiImpl(adaptable);
@@ -82,6 +80,7 @@ export class AdaptableApiImpl {
         this.layoutApi = new LayoutApiImpl(adaptable);
         this.plusMinusApi = new PlusMinusApiImpl(adaptable);
         this.quickSearchApi = new QuickSearchApiImpl(adaptable);
+        this.rowFormApi = new RowFormApiImpl(adaptable);
         this.scheduleApi = new ScheduleApiImpl(adaptable);
         this.shortcutApi = new ShortcutApiImpl(adaptable);
         this.smartEditApi = new SmartEditApiImpl(adaptable);
@@ -101,15 +100,13 @@ export class AdaptableApiImpl {
         this.noteApi = new NoteApiImpl(adaptable);
         this.fdc3Api = new Fdc3ApiImpl(adaptable);
         this.dataImportApi = new DataImportApiImpl(adaptable);
-        this.gridFilterApi = new GridFilterApiImpl(adaptable);
-        this.columnFilterApi = new ColumnFilterApiImpl(adaptable);
+        this.filterApi = new FilterApiImpl(adaptable);
         this.commentApi = new CommentsApiImpl(adaptable);
         // adaptable internal api
         this.internalApi = new AdaptableInternalApi(adaptable);
     }
     get agGridApi() {
-        var _a, _b;
-        return (_b = (_a = this.adaptable) === null || _a === void 0 ? void 0 : _a.agGridAdapter) === null || _b === void 0 ? void 0 : _b.getAgGridApi();
+        return this.adaptable?.agGridAdapter?.getAgGridApi();
     }
     /**
      * This is only meant to be called by the Adaptable instance.
@@ -164,15 +161,13 @@ export class AdaptableApiImpl {
         this.userInterfaceApi = null;
         this.fdc3Api = null;
         this.actionColumnApi = null;
-        this.actionRowApi = null;
         this.calendarApi = null;
-        this.columnFilterApi = null;
+        this.filterApi = null;
         this.columnMenuApi = null;
         this.commentApi = null;
         this.contextMenuApi = null;
         this.dataImportApi = null;
         this.entitlementApi = null;
-        this.gridFilterApi = null;
         this.noteApi = null;
         this.styledColumnApi = null;
     }

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

@@ -20,8 +20,8 @@ export declare class AlertApiImpl extends ApiBase implements AlertApi {
     deleteAlertDefinition(alertDefinition: AlertDefinition): void;
     getAlertDefinitionById(id: AlertDefinition['Uuid']): AlertDefinition;
     addAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
-    showAdaptableAlert(alertToShow: AdaptableAlert): Promise<void>;
-    showAdaptableAlertAsToast(alert: AdaptableAlert): void;
+    displayAdaptableAlert(alertToShow: AdaptableAlert): Promise<void>;
+    displayAdaptableAlertNotification(alert: AdaptableAlert): void;
     showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertProperties): Promise<void>;
     showAlertInfo(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
     showAlertSuccess(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;

package/src/Api/Implementation/AlertApiImpl.js

@@ -1,4 +1,4 @@
-import * as SystemRedux from '../../Redux/ActionsReducers/SystemRedux';
+import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import * as PopupRedux from '../../Redux/ActionsReducers/PopupRedux';
 import * as AlertRedux from '../../Redux/ActionsReducers/AlertRedux';
 import { ApiBase } from './ApiBase';
@@ -16,8 +16,8 @@ export class AlertApiImpl extends ApiBase {
         return this.getAdaptableState().Alert;
     }
     getAlertDefinitions(config) {
-        var _a;
-        return ((_a = this.handleLayoutAssociatedObjects(this.getAlertState().AlertDefinitions, 'Alert', config)) !== null && _a !== void 0 ? _a : []);
+        return (this.handleLayoutAssociatedObjects(this.getAlertState().AlertDefinitions, 'Alert', config) ??
+            []);
     }
     getSuspendedAlertDefinitions(config) {
         return this.getAlertDefinitions(config).filter((alertDefinition) => alertDefinition.IsSuspended);
@@ -29,39 +29,34 @@ export class AlertApiImpl extends ApiBase {
         this.dispatchAction(AlertRedux.AlertDefinitionDelete(alertDefinition));
     }
     getAlertDefinitionById(id) {
-        return this.getAlertDefinitions().find((alert) => (alert === null || alert === void 0 ? void 0 : alert.Uuid) === id);
+        return this.getAlertDefinitions().find((alert) => alert?.Uuid === id);
     }
     addAlertDefinition(alertDefinition) {
         this.addUidToAdaptableObject(alertDefinition);
         this.dispatchAction(AlertRedux.AlertDefinitionAdd(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    async showAdaptableAlert(alertToShow) {
-        var _a, _b;
-        // 3 things we always do with an alert are:
+    async displayAdaptableAlert(alertToShow) {
+        // There are 3 things we always do with an alert:
         // 1. Dispatch the Alert (so it appears in the toolbar)
         this.addUidToAdaptableObject(alertToShow);
-        this.dispatchAction(SystemRedux.SystemAlertAdd(alertToShow, this.getAlertOptions().maxAlertsInStore));
+        this.dispatchAction(InternalRedux.AdaptableAlertAdd(alertToShow, this.getAlertOptions().maxAlertsInStore));
         // 2. Publish the Alert Fired Event
-        const alertFiredInfo = Object.assign(Object.assign({}, this.getAdaptableInternalApi().buildBaseContext()), { alert: alertToShow });
-        const results = await this.getEventApi().emit('AlertFired', alertFiredInfo);
-        const showPopup = results.reduce((endResult, aResult) => {
-            return endResult && aResult !== false;
-        }, true);
+        this.getEventApi().internalApi.fireAlertFiredEvent(alertToShow);
+        // 3. Manage the many different possible Alert behaviours
+        // Note:  alertProperties.PreventEdit is handled separately, in the Adaptable.setupColumnValueSetter() function
         if (alertToShow.alertDefinition && alertToShow.alertDefinition.AlertProperties != undefined) {
             const alertDefinition = alertToShow.alertDefinition;
             const alertProperties = alertDefinition.AlertProperties;
-            // There are 4 possible other actions that could happen
-            // alertProperties.PreventEdit is handled separately, in the Adaptable.setupColumnValueSetter() function
-            // 1. Show a Popup
-            if (alertProperties.DisplayNotification && showPopup) {
-                this.dispatchAction(PopupRedux.PopupShowAlert(alertToShow));
+            // Show a Toast Popup
+            if (alertProperties.DisplayNotification) {
+                this.displayAdaptableAlertNotification(alertToShow);
             }
-            // 2. Log to console
+            // Log to console
             if (alertProperties.LogToConsole) {
                 this.getAdatableLogger().consoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
             }
-            // 3. Show it in a Div (if one has been set)
+            // Show Alert in a Div (if one has been set)
             if (alertProperties.ShowInDiv) {
                 let alertDiv;
                 let optionsDiv = this.getContainerOptions().alertContainer;
@@ -74,23 +69,22 @@ export class AlertApiImpl extends ApiBase {
                     alertDiv.innerHTML = alertString;
                 }
             }
-            // 4.JumpToCell and 5.JumpToRow are exclusive, based on alertType!
-            // 4: Jump to the Cell
+            // Jump to the Cell
             if (alertProperties.JumpToCell &&
                 isAdaptableCellChangedAlert(alertToShow) &&
                 alertToShow.cellDataChangedInfo) {
-                this._adaptable.jumpToCell(alertToShow.cellDataChangedInfo.column.columnId, alertToShow.cellDataChangedInfo.rowNode);
+                this.getGridApi().jumpToCell(alertToShow.cellDataChangedInfo.primaryKeyValue, alertToShow.cellDataChangedInfo.column.columnId, alertToShow.cellDataChangedInfo.rowNode);
             }
-            // 5: Jump to the Row
+            // Jump to the Row
             else if (alertProperties.JumpToRow &&
                 isAdaptableRowChangedAlert(alertToShow) &&
-                ((_a = alertToShow.gridDataChangedInfo) === null || _a === void 0 ? void 0 : _a.rowTrigger) === 'Add') {
-                const [firstRowNode] = alertToShow.gridDataChangedInfo.rowNodes;
+                alertToShow.rowDataChangedInfo?.rowTrigger === 'Add') {
+                const [firstRowNode] = alertToShow.rowDataChangedInfo.rowNodes;
                 if (firstRowNode) {
-                    this._adaptable.jumpToRow(firstRowNode);
+                    this.getGridApi().jumpToRow(firstRowNode);
                 }
             }
-            // 6: For CellChanged Alerts either Highlight the cell or row
+            // For CellChanged Alerts either Highlight the cell or row
             // for former - we just refresh the cells to trigger a re-evaluation of the Adaptable.setupColumn[Style/Class]
             if (isAdaptableCellChangedAlert(alertToShow) &&
                 alertToShow.cellDataChangedInfo &&
@@ -103,35 +97,35 @@ export class AlertApiImpl extends ApiBase {
                     if (alertProperties.HighlightRow) {
                         this.getGridApi().refreshRowNodes([alertNode]);
                         setTimeout(() => {
-                            this.dispatchAction(SystemRedux.SystemAlertRemoveRowHighlight(alertToShow));
+                            this.dispatchAction(InternalRedux.AdaptableAlertRemoveRowHighlight(alertToShow));
                         }, this.getAlertOptions().rowHighlightDuration);
                     }
                     if (alertProperties.HighlightCell) {
-                        this.getGridApi().refreshCells([alertNode], [alertToShow.cellDataChangedInfo.column.columnId]);
+                        this.getGridApi().refreshCell(alertNode, alertToShow.cellDataChangedInfo.column.columnId);
                         setTimeout(() => {
-                            this.dispatchAction(SystemRedux.SystemAlertRemoveCellHighlight(alertToShow));
+                            this.dispatchAction(InternalRedux.AdaptableAlertRemoveCellHighlight(alertToShow));
                         }, this.getAlertOptions().cellHighlightDuration);
                     }
                 }
             }
-            // 7. For RowChange Alerts only Highlight the row - we just refresh the rows to trigger a re-evaluation of the Adaptable.setupColumn[Style/Class]
+            // For RowChange Alerts only Highlight the row - we just refresh the rows to trigger a re-evaluation of the Adaptable.setupColumn[Style/Class]
             else if (alertProperties.HighlightRow &&
                 isAdaptableRowChangedAlert(alertToShow) &&
-                ((_b = alertToShow.gridDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowTrigger) === 'Add') {
-                this.getGridApi().refreshRowNodes(alertToShow.gridDataChangedInfo.rowNodes);
+                alertToShow.rowDataChangedInfo?.rowTrigger === 'Add') {
+                this.getGridApi().refreshRowNodes(alertToShow.rowDataChangedInfo.rowNodes);
                 setTimeout(() => {
-                    this.dispatchAction(SystemRedux.SystemAlertRemoveRowHighlight(alertToShow));
+                    this.dispatchAction(InternalRedux.AdaptableAlertRemoveRowHighlight(alertToShow));
                 }, this.getAlertOptions().rowHighlightDuration);
             }
         }
     }
-    showAdaptableAlertAsToast(alert) {
+    displayAdaptableAlertNotification(alert) {
         this.dispatchAction(PopupRedux.PopupShowAlert(alert));
     }
     async showAlert(alertHeader, alertMessage, messageType, alertProperties) {
         const alertDefinition = ObjectFactory.CreateInternalAlertDefinitionForMessages(messageType, alertProperties);
         let alertToShow = ObjectFactory.CreateGenericAlert(alertHeader, alertMessage, alertDefinition);
-        await this.showAdaptableAlert(alertToShow);
+        await this.displayAdaptableAlert(alertToShow);
     }
     async showAlertInfo(alertHeader, alertMessage, alertProperties) {
         await this.showAlert(alertHeader, alertMessage, 'Info', alertProperties);
@@ -169,7 +163,7 @@ export class AlertApiImpl extends ApiBase {
     evaluateAlertDefinitions(alertDefinitions) {
         const filterScopeAllDefinitions = (alertDefinition) => {
             if (this.getColumnScopeApi().scopeIsAll(alertDefinition.Scope) &&
-                !this.getAdaptableApi().expressionApi.getAdaptableQueryExpression(alertDefinition.Rule)) {
+                !this.getExpressionApi().getAdaptableQueryExpression(alertDefinition.Rule)) {
                 // we don't support scope ALL without an expression
                 // the predicates for scope ALL do NOT make any sense for a programmatic evaluation
                 return false;
@@ -186,12 +180,12 @@ export class AlertApiImpl extends ApiBase {
         }
         const cellDataChangedInfos = this.createCellDataChangeInfoStubs(Array.from(relevantColumnIds));
         cellDataChangedInfos.forEach((cellDataChangedInfo) => {
-            const alertDefinitions = this.getAdaptableApi()
-                .alertApi.internalApi.getAlertDefinitionsForCellDataChange(cellDataChangedInfo)
+            const alertDefinitions = this.internalApi
+                .getAlertDefinitionsForCellDataChange(cellDataChangedInfo)
                 .filter((alertDefinition) => filterScopeAllDefinitions(alertDefinition))
                 // some alert definitions might NOT be relevant for the given locator
                 .filter((alertDefinition) => relevantAlertDefinitions.some((relevantAlertDefinition) => relevantAlertDefinition.Uuid === alertDefinition.Uuid));
-            this.getAdaptableApi().alertApi.internalApi.showAlertForDefinitions(cellDataChangedInfo, alertDefinitions);
+            this.getAlertApi().internalApi.showAlertForDefinitions(cellDataChangedInfo, alertDefinitions);
         });
     }
     findAlertDefinitions(criteria) {
@@ -202,27 +196,27 @@ export class AlertApiImpl extends ApiBase {
     getRelevantColumnIdsForAlertDefinition(alertDefinition) {
         //  if there is an Expression defined, extract only the columns from there (in that case the Scope would be 'All' anyway)
         // columns referenced in rule expression
-        const ruleExpression = this.getAdaptableApi().expressionApi.getAdaptableQueryExpression(alertDefinition.Rule);
+        const ruleExpression = this.getExpressionApi().getAdaptableQueryExpression(alertDefinition.Rule);
         if (this.getColumnScopeApi().scopeIsAll(alertDefinition.Scope) &&
             StringExtensions.IsNotNullOrEmpty(ruleExpression)) {
             // return only first referenced column (otherwise we would generate multiple alerts for the same row)
-            const queryColumns = this.getAdaptableApi()
-                .internalApi.getQueryLanguageService()
+            const queryColumns = this.getAdaptableInternalApi()
+                .getQueryLanguageService()
                 .getColumnsFromExpression(ruleExpression);
             return queryColumns.length > 0 ? [queryColumns[0]] : [];
         }
         else {
             // otherwise return all columns for given scope
-            return this.getAdaptableApi()
-                .columnScopeApi.getColumnsForScope(alertDefinition.Scope)
+            return this.getColumnScopeApi()
+                .getColumnsInScope(alertDefinition.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }
     }
     createCellDataChangeInfoStubs(relevantColumnIds) {
         const cellDataChangeInfos = [];
         //const adaptable: IAdaptable = this.getAdaptableInternalApi().getAdaptableInstance();
-        const relevantColumns = this.getAdaptableApi()
-            .columnApi.getColumnsWithColumnIds(relevantColumnIds)
+        const relevantColumns = this.getColumnApi()
+            .getColumnsWithColumnIds(relevantColumnIds)
             .filter(Boolean);
         const changedAt = Date.now();
         this.getAdaptableInternalApi().forAllRowNodesDo((rowNode) => {