@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

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

@@ -1,51 +1,80 @@
 import { ApiBase, LayoutAssociatedObjectLoadConfig } from './ApiBase';
 import { AlertApi } from '../AlertApi';
-import { AlertState, AlertDefinition, AlertProperties, AdaptableAlertAction, AlertButton } from '../../PredefinedConfig/AlertState';
+import { AdaptableAlertAction, AlertButton, AlertDefinition, AlertProperties, AlertState } from '../../PredefinedConfig/AlertState';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
 import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
 import { AdaptableAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
-import { AdaptableForm, AdaptableFormData } from '../../PredefinedConfig/Common/AdaptableForm';
+import { AdaptableFormData } from '../../PredefinedConfig/Common/AdaptableForm';
 import { AlertFormContext } from '../../AdaptableOptions/AlertOptions';
 import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
 import { GridDataChangedInfo } from '../Events/GridDataChanged';
+import { AdaptableObjectLookupCriteria } from '../../PredefinedConfig/Common/AdaptableObject';
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+import { AlertInternalApi } from '../Internal/AlertInternalApi';
 export declare class AlertApiImpl extends ApiBase implements AlertApi {
+    internalApi: AlertInternalApi;
+    constructor(adaptable: IAdaptable);
     getAlertState(): AlertState;
-    getAdaptableFormByName(name: string): AdaptableForm<AlertFormContext> | undefined;
     getAlertDefinitions(config?: LayoutAssociatedObjectLoadConfig): AlertDefinition[];
+    getSuspendedAlertDefinitions(config?: {
+        includeLayoutNotAssociatedObjects?: boolean;
+    }): AlertDefinition[];
+    getActiveAlertDefinitions(config?: {
+        includeLayoutNotAssociatedObjects?: boolean;
+    }): AlertDefinition[];
+    deleteAlertDefinition(alertDefinition: AlertDefinition): void;
     getAlertDefinitionById(id: AlertDefinition['Uuid']): AlertDefinition;
-    getNonReactiveAlertDefinitions(): AlertDefinition[];
-    getActiveNonReactiveAlertDefinitions(): AlertDefinition[];
-    getReactiveAlertDefinitions(): AlertDefinition[];
-    getActiveReactiveAlertDefinitions(): AlertDefinition[];
-    getAlertDefinitionsWithPreventEdit(): AlertDefinition[];
-    getAlertDefinitionsWithAllowEdit(): AlertDefinition[];
     addAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
-    executeAlertButton(button: AlertButton<AlertFormContext>, context: AlertFormContext): void;
-    executeAlertAction(actionName: AdaptableAlertAction, details: {
-        alertDefinition: AlertDefinition;
-        cellDataChangedInfo?: CellDataChangedInfo;
-        gridDataChangedInfo?: GridDataChangedInfo;
-        formData?: AdaptableFormData;
-    }): void;
-    displayAlert(alertToShow: AdaptableAlert): Promise<any>;
-    publishAlertFiredEvent(alertToFire: AdaptableAlert): void;
+    displayAlert(alertToShow: AdaptableAlert): Promise<void>;
+    showAdaptableAlert(alertToShow: AdaptableAlert): Promise<void>;
     displayMessageAlertPopup(alertToDisplayAsPopup: AdaptableAlert): void;
-    showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertProperties): void;
-    showAlertInfo(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): void;
-    showAlertSuccess(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): void;
-    showAlertWarning(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): void;
-    showAlertError(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): void;
+    showAdaptableAlertAsToast(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>;
+    showAlertWarning(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
+    showAlertError(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
+    openAlertSettingsPanel(): void;
     showAlertPopup(): void;
-    getAlertPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
     editAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
     suspendAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
     unSuspendAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
-    getAlertMessageTitle(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string | undefined;
+    evaluateAlerts(alertDefinitions: AlertDefinition[]): void;
+    findAlertDefinitions(criteria: AdaptableObjectLookupCriteria): AlertDefinition[];
+    private getRelevantColumnIdsForAlertDefinition;
+    private createCellDataChangeInfoStubs;
+    /**
+     *  DEPRECATED INTERNAL METHODS
+     */
+    executeAlertAction(actionName: AdaptableAlertAction | string, details: {
+        alertDefinition: AlertDefinition;
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+        formData?: AdaptableFormData;
+    }): void;
+    executeAlertButton(button: AlertButton<AlertFormContext>, context: AlertFormContext): void;
+    getActiveNonReactiveAlertDefinitions(): AlertDefinition[];
+    getActiveReactiveAlertDefinitions(): AlertDefinition[];
+    getAlertDefinitionsWithAllowEdit(): AlertDefinition[];
+    getAlertDefinitionsWithPreventEdit(): AlertDefinition[];
     getAlertDescription(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
-    getAlertRuleDescription(alert: AlertDefinition): string;
+    getAlertMessageTitle(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
+    getAlertPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    getAlertRuleDescription(alertDefinition: AlertDefinition): string;
+    getAlertTypeForAdaptableAlert(alert: AdaptableAlert): 'cellChanged' | 'rowChanged' | 'generic';
+    getCustomAlertDescription(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    getCustomAlertMessageTitle(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    getNonReactiveAlertDefinitions(): AlertDefinition[];
+    getReactiveAlertDefinitions(): AlertDefinition[];
     isCellChangedAdaptableAlert(alert: AdaptableAlert): boolean;
-    isRowChangedAdaptableAlert(alert: AdaptableAlert): boolean;
     isGenericAdaptableAlert(alert: AdaptableAlert): boolean;
-    getAlertTypeForAdaptableAlert(alert: AdaptableAlert): 'cellChanged' | 'rowChanged' | 'generic';
+    isRowChangedAdaptableAlert(alert: AdaptableAlert): boolean;
+    publishAlertFiredEvent(alertToFire: AdaptableAlert): void;
 }

package/src/Api/Implementation/AlertApiImpl.js

@@ -10,158 +10,43 @@ const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
 const AdaptableAlert_1 = require("../../PredefinedConfig/Common/AdaptableAlert");
-const AdaptableQuery_1 = require("../../PredefinedConfig/Common/AdaptableQuery");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const AlertInternalApi_1 = require("../Internal/AlertInternalApi");
+const logDeprecation_1 = require("../../Utilities/logDeprecation");
 class AlertApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new AlertInternalApi_1.AlertInternalApi(adaptable);
+    }
     getAlertState() {
         return this.getAdaptableState().Alert;
     }
-    getAdaptableFormByName(name) {
-        var _a;
-        const alertForms = this.getAlertOptions().alertForms || [];
-        return (_a = alertForms.find((f) => f.name === name)) === null || _a === void 0 ? void 0 : _a.form;
-    }
     getAlertDefinitions(config) {
         var _a;
         return ((_a = this.handleLayoutAssociatedObjects(this.getAlertState().AlertDefinitions, 'Alert', config)) !== null && _a !== void 0 ? _a : []);
     }
-    getAlertDefinitionById(id) {
-        return this.getAlertDefinitions().find((alert) => (alert === null || alert === void 0 ? void 0 : alert.Uuid) === id);
-    }
-    getNonReactiveAlertDefinitions() {
-        return this.getAlertDefinitions().filter((alertDef) => !(0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
-    }
-    getActiveNonReactiveAlertDefinitions() {
-        return this.getNonReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
-    }
-    getReactiveAlertDefinitions() {
-        return this.getAlertDefinitions().filter((alertDef) => (0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
+    getSuspendedAlertDefinitions(config) {
+        return this.getAlertDefinitions(config).filter((alertDefinition) => alertDefinition.IsSuspended);
     }
-    getActiveReactiveAlertDefinitions() {
-        return this.getReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
+    getActiveAlertDefinitions(config) {
+        return this.getAlertDefinitions(config).filter((alertDefinition) => !alertDefinition.IsSuspended);
     }
-    getAlertDefinitionsWithPreventEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties != null && a.AlertProperties.PreventEdit === true);
+    deleteAlertDefinition(alertDefinition) {
+        this.dispatchAction(AlertRedux.AlertDefinitionDelete(alertDefinition));
     }
-    getAlertDefinitionsWithAllowEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties == null || a.AlertProperties.PreventEdit !== true);
+    getAlertDefinitionById(id) {
+        return this.getAlertDefinitions().find((alert) => (alert === null || alert === void 0 ? void 0 : alert.Uuid) === id);
     }
     addAlertDefinition(alertDefinition) {
         this.addUidToAdaptableObject(alertDefinition);
         this.dispatchAction(AlertRedux.AlertDefinitionAdd(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    executeAlertButton(button, context) {
-        if (button.Action) {
-            let actions = button.Action;
-            if (typeof actions === 'function') {
-                actions(context);
-                return;
-            }
-            if (!Array.isArray(actions)) {
-                actions = [actions];
-            }
-            actions.forEach((action) => {
-                var _a;
-                const buttonOnClick = (_a = this.getAlertOptions().actionHandlers) === null || _a === void 0 ? void 0 : _a.find((x) => x.name === action);
-                buttonOnClick === null || buttonOnClick === void 0 ? void 0 : buttonOnClick.handler(button, context);
-                this.adaptable.api.alertApi.executeAlertAction(action, {
-                    alertDefinition: context.alert.alertDefinition,
-                    cellDataChangedInfo: (0, AdaptableAlert_1.isAdaptableCellChangedAlert)(context.alert)
-                        ? context.alert.cellDataChangedInfo
-                        : null,
-                    gridDataChangedInfo: (0, AdaptableAlert_1.isAdaptableRowChangedAlert)(context.alert)
-                        ? context.alert.gridDataChangedInfo
-                        : null,
-                    formData: context.formData,
-                });
-            });
-        }
-    }
-    executeAlertAction(actionName, details) {
-        const { alertDefinition, cellDataChangedInfo: cellDataChangedInfo, gridDataChangedInfo, } = details;
-        const getBackgroundColor = (alertDefinition) => {
-            var _a;
-            const highlightType = (_a = alertDefinition.MessageType) !== null && _a !== void 0 ? _a : 'Info';
-            let backgroundColor = '';
-            switch (highlightType) {
-                case 'Error':
-                    backgroundColor = 'var(--ab-color-error)';
-                    break;
-                case 'Info':
-                    backgroundColor = 'var(--ab-color-info)';
-                    break;
-                case 'Success':
-                    backgroundColor = 'var(--ab-color-success)';
-                    break;
-                case 'Warning':
-                    backgroundColor = 'var(--ab-color-warn)';
-            }
-            return backgroundColor;
-        };
-        if (actionName === 'highlight-cell' && cellDataChangedInfo) {
-            const backgroundColor = getBackgroundColor(alertDefinition);
-            this.adaptable.api.gridApi.highlightCell({
-                columnId: cellDataChangedInfo.column.columnId,
-                primaryKeyValue: cellDataChangedInfo.primaryKeyValue,
-                highlightStyle: {
-                    BackColor: backgroundColor,
-                },
-                timeout: this.getAlertOptions().cellHighlightDuration,
-            });
-        }
-        if (actionName === 'highlight-row' && cellDataChangedInfo) {
-            const rowsHighlightInfo = {
-                primaryKeyValues: [cellDataChangedInfo.primaryKeyValue],
-                highlightStyle: {
-                    BackColor: getBackgroundColor(alertDefinition),
-                },
-                timeout: this.getAlertOptions().rowHighlightDuration,
-            };
-            this.adaptable.api.gridApi.highlightRows(rowsHighlightInfo);
-        }
-        if (actionName === 'highlight-row' &&
-            gridDataChangedInfo &&
-            // no sense to highlight a deleted(non-existing) row
-            (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete') {
-            const primaryKeyValues = this.adaptable.api.gridApi.getPrimaryKeyValuesForRowNodes(gridDataChangedInfo.rowNodes);
-            const rowsHighlightInfo = {
-                primaryKeyValues,
-                highlightStyle: {
-                    BackColor: getBackgroundColor(alertDefinition),
-                },
-                timeout: this.getAlertOptions().rowHighlightDuration,
-            };
-            this.adaptable.api.gridApi.highlightRows(rowsHighlightInfo);
-        }
-        if (actionName === 'jump-to-cell' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.jumpToCell(cellDataChangedInfo.primaryKeyValue, cellDataChangedInfo.column.columnId);
-        }
-        if (actionName === 'jump-to-row' &&
-            // either a cell change
-            (cellDataChangedInfo ||
-                // or a grid change, but NOT row deletion
-                (gridDataChangedInfo &&
-                    // no sense to jump to a deleted(non-existing) row
-                    (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete'))) {
-            const [firstRowNode] = cellDataChangedInfo
-                ? [cellDataChangedInfo.rowNode]
-                : gridDataChangedInfo.rowNodes;
-            const targetRowNodePrimaryKeyValue = this.adaptable.api.gridApi.getPrimaryKeyValueForRowNode(firstRowNode);
-            if (targetRowNodePrimaryKeyValue) {
-                this.adaptable.api.gridApi.jumpToRow(targetRowNodePrimaryKeyValue);
-            }
-        }
-        if (actionName === 'jump-to-column' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.jumpToColumn(cellDataChangedInfo.column.columnId);
-        }
-        if (actionName === 'suspend') {
-            this.adaptable.api.alertApi.suspendAlertDefinition(alertDefinition);
-        }
-        if (actionName === 'undo' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.undoCellEdit(cellDataChangedInfo);
-        }
-    }
     async displayAlert(alertToShow) {
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'displayAlert', 'showAdaptableAlert');
+        await this.showAdaptableAlert(alertToShow);
+    }
+    async showAdaptableAlert(alertToShow) {
         var _a, _b;
         // 3 things we always do with an alert are:
         // 1. Dispatch the Alert (so it appears in the toolbar)
@@ -253,40 +138,36 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
             }
         }
     }
-    publishAlertFiredEvent(alertToFire) {
-        const alertFiredInfo = {
-            adaptableApi: this.adaptable.api,
-            alert: alertToFire,
-        };
-        this.adaptable.api.eventApi.emit('AlertFired', alertFiredInfo);
-    }
     displayMessageAlertPopup(alertToDisplayAsPopup) {
-        this.dispatchAction(PopupRedux.PopupShowAlert(alertToDisplayAsPopup));
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'displayMessageAlertPopup', 'showAdaptableAlertAsToast');
+        this.showAdaptableAlertAsToast(alertToDisplayAsPopup);
+    }
+    showAdaptableAlertAsToast(alert) {
+        this.dispatchAction(PopupRedux.PopupShowAlert(alert));
     }
-    showAlert(alertHeader, alertMessage, messageType, alertProperties) {
+    async showAlert(alertHeader, alertMessage, messageType, alertProperties) {
         const alertDefinition = ObjectFactory_1.default.CreateInternalAlertDefinitionForMessages(messageType, alertProperties);
         let alertToShow = ObjectFactory_1.default.CreateGenericAlert(alertHeader, alertMessage, alertDefinition);
-        this.displayAlert(alertToShow);
+        await this.showAdaptableAlert(alertToShow);
     }
-    showAlertInfo(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Info', alertProperties);
+    async showAlertInfo(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Info', alertProperties);
     }
-    showAlertSuccess(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Success', alertProperties);
+    async showAlertSuccess(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Success', alertProperties);
     }
-    showAlertWarning(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Warning', alertProperties);
+    async showAlertWarning(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Warning', alertProperties);
     }
-    showAlertError(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Error', alertProperties);
+    async showAlertError(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Error', alertProperties);
     }
-    showAlertPopup() {
+    openAlertSettingsPanel() {
         this.showModulePopup(ModuleConstants.AlertModuleId);
     }
-    getAlertPredicateDefsForScope(scope) {
-        return this.getAdaptableApi()
-            .predicateApi.getAlertPredicateDefs()
-            .filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    showAlertPopup() {
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'showAlertPopup', 'openAlertSettingsPanel');
+        this.openAlertSettingsPanel();
     }
     editAlertDefinition(alertDefinition) {
         this.dispatchAction(AlertRedux.AlertDefinitionEdit(alertDefinition));
@@ -300,57 +181,158 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         this.dispatchAction(AlertRedux.AlertDefinitionUnSuspend(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    getAlertMessageTitle(alertDefinition, cellDataChangedInfo) {
-        var _a, _b;
-        const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageTitle;
-        if (alertMessageFunction) {
-            const returnText = alertMessageFunction({ alertDefinition, cellDataChangedInfo });
-            if (returnText) {
-                return returnText;
+    evaluateAlerts(alertDefinitions) {
+        const filterScopeAllDefinitions = (alertDefinition) => {
+            if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+                !this.getAdaptableApi().queryLanguageApi.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;
             }
+            return true;
+        };
+        const relevantAlertDefinitions = alertDefinitions.filter((alertDefinition) => filterScopeAllDefinitions(alertDefinition));
+        const relevantColumnIds = new Set();
+        relevantAlertDefinitions.forEach((alertDefinition) => {
+            this.getRelevantColumnIdsForAlertDefinition(alertDefinition).forEach((relevantColumnId) => relevantColumnIds.add(relevantColumnId));
+        });
+        if (!relevantColumnIds.size) {
+            return;
         }
-        if (alertDefinition.MessageHeader) {
-            return alertDefinition.MessageHeader;
+        const cellDataChangedInfos = this.createCellDataChangeInfoStubs(Array.from(relevantColumnIds));
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+            const alertDefinitions = this.getAdaptableApi()
+                .alertApi.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);
+        });
+    }
+    findAlertDefinitions(criteria) {
+        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions({
+            includeLayoutNotAssociatedObjects: true,
+        }));
+    }
+    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().queryLanguageApi.getAdaptableQueryExpression(alertDefinition.Rule);
+        if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+            StringExtensions_1.default.IsNotNullOrEmpty(ruleExpression)) {
+            // return only first referenced column (otherwise we would generate multiple alerts for the same row)
+            const queryColumns = this.getAdaptableApi()
+                .internalApi.getQueryLanguageService()
+                .getColumnsFromExpression(ruleExpression);
+            return queryColumns.length > 0 ? [queryColumns[0]] : [];
         }
-        return (_b = cellDataChangedInfo === null || cellDataChangedInfo === void 0 ? void 0 : cellDataChangedInfo.column) === null || _b === void 0 ? void 0 : _b.friendlyName;
+        else {
+            // otherwise return all columns for given scope
+            return this.getAdaptableApi()
+                .scopeApi.getColumnsForScope(alertDefinition.Scope)
+                .map((adaptableColumn) => adaptableColumn.columnId);
+        }
+    }
+    createCellDataChangeInfoStubs(relevantColumnIds) {
+        const cellDataChangeInfos = [];
+        const relevantColumns = this.getAdaptableApi()
+            .columnApi.getColumnsWithColumnIds(relevantColumnIds)
+            .filter(Boolean);
+        const changedAt = Date.now();
+        this.adaptable.forAllRowNodesDo((rowNode) => {
+            relevantColumns.forEach((column) => {
+                const cellDataChangeInfoStub = {
+                    changedAt,
+                    rowNode,
+                    column,
+                    rowData: rowNode.data,
+                    oldValue: null,
+                    newValue: this.adaptable.getRawValueFromRowNode(rowNode, column.columnId),
+                    primaryKeyValue: this.adaptable.getPrimaryKeyValueFromRowNode(rowNode),
+                };
+                cellDataChangeInfos.push(cellDataChangeInfoStub);
+            });
+        });
+        return cellDataChangeInfos;
+    }
+    /**
+     *  DEPRECATED INTERNAL METHODS
+     */
+    executeAlertAction(actionName, details) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertAction');
+        this.internalApi.executeAlertAction(actionName, details);
+    }
+    executeAlertButton(button, context) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertButton');
+        this.internalApi.executeAlertButton(button, context);
+    }
+    getActiveNonReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertButton');
+        return this.internalApi.getActiveNonReactiveAlertDefinitions();
+    }
+    getActiveReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getActiveReactiveAlertDefinitions');
+        return this.internalApi.getActiveReactiveAlertDefinitions();
+    }
+    getAlertDefinitionsWithAllowEdit() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDefinitionsWithAllowEdit');
+        return this.internalApi.getAlertDefinitionsWithAllowEdit();
+    }
+    getAlertDefinitionsWithPreventEdit() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDefinitionsWithPreventEdit');
+        return this.internalApi.getAlertDefinitionsWithPreventEdit();
     }
     getAlertDescription(alertDefinition, cellDataChangedInfo) {
-        var _a;
-        const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageText;
-        if (alertMessageFunction) {
-            const alertMessageContext = {
-                alertDefinition: alertDefinition,
-                cellDataChangedInfo: cellDataChangedInfo,
-            };
-            const returnText = alertMessageFunction(alertMessageContext);
-            if (returnText) {
-                return returnText;
-            }
-        }
-        if (alertDefinition.MessageText != null) {
-            return alertDefinition.MessageText;
-        }
-        let scopeDescription = this.adaptable.api.scopeApi.getScopeDescription(alertDefinition.Scope);
-        let ruleDescription = this.getAlertRuleDescription(alertDefinition);
-        return scopeDescription + ' - ' + ruleDescription;
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDescription');
+        return this.internalApi.getAlertDescription(alertDefinition, cellDataChangedInfo);
     }
-    getAlertRuleDescription(alert) {
-        let ruleDescription = alert.Rule.Predicate
-            ? this.adaptable.api.predicateApi.predicateToString(alert.Rule.Predicate)
-            : this.adaptable.api.internalApi.getAdaptableQueryExpressionText(alert.Rule);
-        return ruleDescription;
+    getAlertMessageTitle(alertDefinition, cellDataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertMessageTitle');
+        return this.internalApi.getAlertMessageTitle(alertDefinition, cellDataChangedInfo);
     }
-    isCellChangedAdaptableAlert(alert) {
-        return alert.alertType === 'cellChanged';
+    getAlertPredicateDefsForScope(scope) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertPredicateDefsForScope');
+        return this.internalApi.getAlertPredicateDefsForScope(scope);
     }
-    isRowChangedAdaptableAlert(alert) {
-        return alert.alertType === 'rowChanged';
+    getAlertRuleDescription(alertDefinition) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertRuleDescription');
+        return this.internalApi.getAlertRuleDescription(alertDefinition);
+    }
+    getAlertTypeForAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertTypeForAdaptableAlert');
+        return this.internalApi.getAlertTypeForAdaptableAlert(alert);
+    }
+    getCustomAlertDescription(alertDefinition, dataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getCustomAlertDescription');
+        return this.internalApi.getCustomAlertDescription(alertDefinition, dataChangedInfo);
+    }
+    getCustomAlertMessageTitle(alertDefinition, dataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getCustomAlertMessageTitle');
+        return this.internalApi.getCustomAlertMessageTitle(alertDefinition, dataChangedInfo);
+    }
+    getNonReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getNonReactiveAlertDefinitions');
+        return this.internalApi.getNonReactiveAlertDefinitions();
+    }
+    getReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getReactiveAlertDefinitions');
+        return this.internalApi.getReactiveAlertDefinitions();
+    }
+    isCellChangedAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isCellChangedAdaptableAlert');
+        return this.internalApi.isCellChangedAdaptableAlert(alert);
     }
     isGenericAdaptableAlert(alert) {
-        return alert.alertType === 'generic';
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isGenericAdaptableAlert');
+        return this.internalApi.isGenericAdaptableAlert(alert);
     }
-    getAlertTypeForAdaptableAlert(alert) {
-        return alert.alertType;
+    isRowChangedAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isRowChangedAdaptableAlert');
+        return this.internalApi.isRowChangedAdaptableAlert(alert);
+    }
+    publishAlertFiredEvent(alertToFire) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'publishAlertFiredEvent');
+        return this.internalApi.publishAlertFiredEvent(alertToFire);
     }
 }
 exports.AlertApiImpl = AlertApiImpl;

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

@@ -7,7 +7,7 @@ import { ModuleInfo } from '../../Strategy/Interface/IModule';
 import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
-import { ActionOptions, ContainerOptions, DashboardOptions, EditOptions, FilterOptions, GeneralOptions, LayoutAssociatedObject, LayoutOptions, MenuOptions, SearchOptions, StateOptions, TeamSharingOptions, UserInterfaceOptions } from '../../types';
+import { ActionApi, ActionOptions, AlertApi, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CellSummaryApi, ChartingApi, ColumnApi, ConfigApi, ContainerOptions, CustomSortApi, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataSetApi, EditOptions, EntitlementApi, EventApi, ExportApi, FilterApi, FilterOptions, FlashingCellApi, FormatColumnApi, FreeTextColumnApi, GeneralOptions, GridApi, LayoutApi, LayoutAssociatedObject, LayoutOptions, MenuOptions, PluginsApi, PlusMinusApi, PredicateApi, QueryApi, QueryLanguageApi, QuickSearchApi, ScheduleApi, ScopeApi, SearchOptions, SettingsPanelApi, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, UserInterfaceApi, UserInterfaceOptions } from '../../types';
 import { NotificationsOptions } from '../../AdaptableOptions/NotificationsOptions';
 import { ToolPanelOptions } from '../../AdaptableOptions/ToolPanelOptions';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
@@ -32,7 +32,7 @@ export declare abstract class ApiBase {
      */
     protected checkItemExists(item: any, name: string, type: string): boolean;
     protected checkArrayExists(array: any): boolean;
-    protected handleLayoutAssociatedObjects<T extends LayoutAssociatedObject>(associatedObjects: T[], module: AdaptableModule, config?: {
+    protected handleLayoutAssociatedObjects<T extends LayoutAssociatedObject>(objectList: T[], module: AdaptableModule, config?: {
         includeLayoutNotAssociatedObjects?: boolean;
         associatedWithLayout?: string;
     }): T[];
@@ -71,6 +71,47 @@ export declare abstract class ApiBase {
     protected getToolPanelOptions(): ToolPanelOptions;
     protected getExpressionOptions(): ExpressionOptions;
     protected getAdaptableApi(): AdaptableApi;
+    protected getActionApi(): ActionApi;
+    protected getApplicationApi(): ApplicationApi;
+    protected getAlertApi(): AlertApi;
+    protected getFlashingCellApi(): FlashingCellApi;
+    protected getPredicateApi(): PredicateApi;
+    protected getBulkUpdateApi(): BulkUpdateApi;
+    protected getCalendarApi(): CalendarApi;
+    protected getCalculatedColumnApi(): CalculatedColumnApi;
+    protected getCellSummaryApi(): CellSummaryApi;
+    protected getColumnApi(): ColumnApi;
+    protected getConfigApi(): ConfigApi;
+    protected getCustomSortApi(): CustomSortApi;
+    protected getDashboardApi(): DashboardApi;
+    protected getDataSetApi(): DataSetApi;
+    protected getEntitlementApi(): EntitlementApi;
+    protected getEventApi(): EventApi;
+    protected getExportApi(): ExportApi;
+    protected getFormatColumnApi(): FormatColumnApi;
+    protected getFreeTextColumnApi(): FreeTextColumnApi;
+    protected getGridApi(): GridApi;
+    protected getLayoutApi(): LayoutApi;
+    protected getPlusMinusApi(): PlusMinusApi;
+    protected getQuickSearchApi(): QuickSearchApi;
+    protected getScheduleApi(): ScheduleApi;
+    protected getShortcutApi(): ShortcutApi;
+    protected getSmartEditApi(): SmartEditApi;
+    protected getFilterApi(): FilterApi;
+    protected getSystemStatusApi(): SystemStatusApi;
+    protected getThemeApi(): ThemeApi;
+    protected getUserInterfaceApi(): UserInterfaceApi;
+    protected getQueryApi(): QueryApi;
+    protected getQueryLanguageApi(): QueryLanguageApi;
+    protected getPluginsApi(): PluginsApi;
+    protected getSettingsPanelApi(): SettingsPanelApi;
+    protected getStyledColumnApi(): StyledColumnApi;
+    protected getToolPanelApi(): ToolPanelApi;
+    protected getTeamSharingApi(): TeamSharingApi;
+    protected getScopeApi(): ScopeApi;
+    protected getDataChangeHistoryApi(): DataChangeHistoryApi;
+    protected getChartingApi(): ChartingApi;
+    protected getStatusBarApi(): StatusBarApi;
     destroy(): void;
 }
 /**