@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.1

package/src/Api/Internal/AlertInternalApi.d.ts

@@ -0,0 +1,148 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableForm, AdaptableFormData } from '../../PredefinedConfig/Common/AdaptableForm';
+import { AlertFormContext } from '../../AdaptableOptions/AlertOptions';
+import { AdaptableAlertAction, AlertButton, AlertButtonForm, AlertDefinition } from '../../PredefinedConfig/AlertState';
+import { AdaptableAlert, AdaptableCellChangedAlert, AdaptableRowChangedAlert } from '../../PredefinedConfig/Common/AdaptableAlert';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridDataChangedInfo } from '../Events/GridDataChanged';
+import { AdaptableScope } from '../../PredefinedConfig/Common/AdaptableScope';
+import { AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
+import { AdaptableMessageType } from '../../PredefinedConfig/Common/AdaptableMessageType';
+import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
+import { ButtonStyle } from '../../PredefinedConfig/Common/ButtonStyle';
+import { RowNode } from '@ag-grid-community/core';
+export declare class AlertInternalApi extends ApiBase {
+    /**
+     * Retrieves the Adaptable Form with the given name
+     * @param name name of the Form
+     */
+    getAdaptableFormByName(name: string): AdaptableForm<AlertFormContext> | undefined;
+    /**
+     * Retrieves all Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getNonReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getActiveNonReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     *
+     * Retrieves all Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     *
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getActiveReactiveAlertDefinitions(): AlertDefinition[];
+    /**
+     * Retrieves all Alert Definitions which prevent a Cell Edit
+     * @returns alert definitions
+     */
+    getAlertDefinitionsWithPreventEdit(): AlertDefinition[];
+    /**
+     * Retrieves all Alert Definitions which allow a Cell Edit
+     *  @returns alert definitions
+     */
+    getAlertDefinitionsWithAllowEdit(): AlertDefinition[];
+    /**
+     * Publishes an event when an Alert is triggered
+     * @param alertToFire Alerts which has just triggered
+     */
+    publishAlertFiredEvent(alertToFire: AdaptableAlert): void;
+    /**
+     * Runs after a button in an Alert Form is clicked
+     */
+    executeAlertButton(button: AlertButton<AlertFormContext>, context: AlertFormContext): void;
+    /**
+     * Runs after an Alert Action is invoked
+     * @param actionName Action which has been invoked
+     * @param details Info about the Alert and Form
+     */
+    executeAlertAction(actionName: AdaptableAlertAction | string, details: {
+        alertDefinition: AlertDefinition;
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+        formData?: AdaptableFormData;
+    }): void;
+    /**
+     * Retrieves all Predicate Defs that match given Scope
+     * @param scope the Scope to check
+     */
+    getAlertPredicateDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    /**
+     * Returns a description of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertDescription(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
+    /**
+     * Returns a description title of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertMessageTitle(alertDefinition: AlertDefinition, cellDataChangedInfo?: CellDataChangedInfo): string;
+    /**
+     * Returns custom description for alert using the 'alertMessageText' property
+     *
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertDescription(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    /**
+     * Returns custom title defined by 'alertMessageTitle' property
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo Data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertMessageTitle(alertDefinition: AlertDefinition, dataChangedInfo?: {
+        cellDataChangedInfo?: CellDataChangedInfo;
+        gridDataChangedInfo?: GridDataChangedInfo;
+    }): string;
+    /**
+     * Returns a description of an Alert Definition's Rule
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertRuleDescription(alertDefinition: AlertDefinition): string;
+    /**
+     * Was Adaptable Alert fired due to a Cell Change
+     * @param alert AdaptableAlert to check
+     */
+    isCellChangedAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Was Adaptable Alert fired due to a Row Change
+     * @param alert AdaptableAlert to check
+     */
+    isRowChangedAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Is Adaptable Alert a Generic one
+     * @param alert AdaptableAlert to check
+     */
+    isGenericAdaptableAlert(alert: AdaptableAlert): boolean;
+    /**
+     * Returns for the Alert Type for an Adaptable Alert
+     * @param alert AdaptableAlert to check
+     */
+    getAlertTypeForAdaptableAlert(alert: AdaptableAlert): 'cellChanged' | 'rowChanged' | 'generic';
+    getAdaptableFormFromAlertForm(alertForm: string | AlertButtonForm, context: any, defaultMessageType?: AdaptableMessageType): (Omit<AdaptableForm<AlertFormContext>, 'buttons'> & {
+        buttons?: (Omit<AdaptableButton<AlertFormContext>, 'buttonStyle'> & {
+            buttonStyle?: ButtonStyle;
+        })[];
+    }) | undefined;
+    getAdaptableAlerts(): AdaptableAlert[];
+    getAdaptableCellChangedAlerts(): AdaptableCellChangedAlert[];
+    getAdaptableRowChangedAlerts(): AdaptableRowChangedAlert[];
+    getAdaptableAlertWithHighlightCell(columnId: string, rowNode: RowNode): AdaptableAlert | undefined;
+    getAdaptableAlertWithHighlightRow(rowNode: RowNode): AdaptableAlert | undefined;
+    isAlertDefinitionForAddedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    isAlertDefinitionForRemovedRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    getAlertDefinitionsForCellDataChange(dataChangedEvent: CellDataChangedInfo): AlertDefinition[];
+    private isAggregationAlertTriggered;
+    private isAlertPredicateTriggered;
+    isAlertDefinitionForRowChangeEvent(alertDefinition: AlertDefinition): boolean;
+    showAlertForDefinitions(cellDataChangedInfo: CellDataChangedInfo, alertDefinitions?: AlertDefinition[]): void;
+}

package/src/Api/Internal/AlertInternalApi.js

@@ -0,0 +1,484 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const AdaptableAlert_1 = require("../../PredefinedConfig/Common/AdaptableAlert");
+const AdaptableQuery_1 = require("../../PredefinedConfig/Common/AdaptableQuery");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+const ModuleConstants_1 = require("../../Utilities/Constants/ModuleConstants");
+const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+class AlertInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Retrieves the Adaptable Form with the given name
+     * @param name name of the Form
+     */
+    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;
+    }
+    /**
+     * Retrieves all Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getNonReactiveAlertDefinitions() {
+        return this.getAlertApi()
+            .getAlertDefinitions()
+            .filter((alertDef) => !(0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
+    }
+    /**
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
+     * @returns alert definitions
+     */
+    getActiveNonReactiveAlertDefinitions() {
+        return this.getNonReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
+    }
+    /**
+     *
+     * Retrieves all Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getReactiveAlertDefinitions() {
+        return this.getAlertApi()
+            .getAlertDefinitions()
+            .filter((alertDef) => (0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
+    }
+    /**
+     *
+     * Retrieves all active (non-suspended) Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
+     * @returns alert definitions
+     */
+    getActiveReactiveAlertDefinitions() {
+        return this.getReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
+    }
+    /**
+     * Retrieves all Alert Definitions which prevent a Cell Edit
+     * @returns alert definitions
+     */
+    getAlertDefinitionsWithPreventEdit() {
+        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties != null && a.AlertProperties.PreventEdit === true);
+    }
+    /**
+     * Retrieves all Alert Definitions which allow a Cell Edit
+     *  @returns alert definitions
+     */
+    getAlertDefinitionsWithAllowEdit() {
+        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties == null || a.AlertProperties.PreventEdit !== true);
+    }
+    /**
+     * Publishes an event when an Alert is triggered
+     * @param alertToFire Alerts which has just triggered
+     */
+    publishAlertFiredEvent(alertToFire) {
+        const alertFiredInfo = {
+            adaptableApi: this.getAdaptableApi(),
+            alert: alertToFire,
+        };
+        this.getEventApi().emit('AlertFired', alertFiredInfo);
+    }
+    /**
+     * Runs after a button in an Alert Form is clicked
+     */
+    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.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,
+                });
+            });
+        }
+    }
+    /**
+     * Runs after an Alert Action is invoked
+     * @param actionName Action which has been invoked
+     * @param details Info about the Alert and Form
+     */
+    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.getGridApi().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.getGridApi().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.getGridApi().getPrimaryKeyValuesForRowNodes(gridDataChangedInfo.rowNodes);
+            const rowsHighlightInfo = {
+                primaryKeyValues,
+                highlightStyle: {
+                    BackColor: getBackgroundColor(alertDefinition),
+                },
+                timeout: this.getAlertOptions().rowHighlightDuration,
+            };
+            this.getGridApi().highlightRows(rowsHighlightInfo);
+        }
+        if (actionName === 'jump-to-cell' && cellDataChangedInfo) {
+            this.getGridApi().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.getGridApi().getPrimaryKeyValueForRowNode(firstRowNode);
+            if (targetRowNodePrimaryKeyValue) {
+                this.getGridApi().jumpToRow(targetRowNodePrimaryKeyValue);
+            }
+        }
+        if (actionName === 'jump-to-column' && cellDataChangedInfo) {
+            this.getGridApi().jumpToColumn(cellDataChangedInfo.column.columnId);
+        }
+        if (actionName === 'suspend') {
+            this.getAlertApi().suspendAlertDefinition(alertDefinition);
+        }
+        if (actionName === 'undo' && cellDataChangedInfo) {
+            this.getGridApi().undoCellEdit(cellDataChangedInfo);
+        }
+    }
+    /**
+     * Retrieves all Predicate Defs that match given Scope
+     * @param scope the Scope to check
+     */
+    getAlertPredicateDefsForScope(scope) {
+        return this.getPredicateApi()
+            .internalApi.getAlertPredicateDefs()
+            .filter((predicateDef) => this.getScopeApi().isScopeInScope(scope, predicateDef.columnScope));
+    }
+    /**
+     * Returns a description of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertDescription(alertDefinition, cellDataChangedInfo) {
+        const customMessage = this.getCustomAlertDescription(alertDefinition, { cellDataChangedInfo });
+        if (customMessage) {
+            return customMessage;
+        }
+        if (alertDefinition.MessageText != null) {
+            return alertDefinition.MessageText;
+        }
+        let scopeDescription = this.getScopeApi().getScopeDescription(alertDefinition.Scope);
+        let ruleDescription = this.getAlertRuleDescription(alertDefinition);
+        return scopeDescription + ' - ' + ruleDescription;
+    }
+    /**
+     * Returns a description title of an Alert Definition
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertMessageTitle(alertDefinition, cellDataChangedInfo) {
+        var _a, _b;
+        return ((_a = this.getCustomAlertMessageTitle(alertDefinition, {
+            cellDataChangedInfo,
+        })) !== null && _a !== void 0 ? _a : (_b = cellDataChangedInfo === null || cellDataChangedInfo === void 0 ? void 0 : cellDataChangedInfo.column) === null || _b === void 0 ? void 0 : _b.friendlyName);
+    }
+    /**
+     * Returns custom description for alert using the 'alertMessageText' property
+     *
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertDescription(alertDefinition, dataChangedInfo) {
+        var _a;
+        const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageText;
+        if (alertMessageFunction) {
+            const alertMessageContext = {
+                alertDefinition: alertDefinition,
+                cellDataChangedInfo: dataChangedInfo.cellDataChangedInfo,
+                gridDataChangedInfo: dataChangedInfo.gridDataChangedInfo,
+            };
+            const returnText = alertMessageFunction(alertMessageContext);
+            if (returnText) {
+                return returnText;
+            }
+        }
+        return null;
+    }
+    /**
+     * Returns custom title defined by 'alertMessageTitle' property
+     * @param alertDefinition Alert Definition to use
+     * @param dataChangedInfo Data change info, it can be eighter grid or cell data chantged info
+     */
+    getCustomAlertMessageTitle(alertDefinition, dataChangedInfo) {
+        var _a;
+        const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageTitle;
+        if (alertMessageFunction) {
+            const returnText = alertMessageFunction({
+                alertDefinition,
+                cellDataChangedInfo: dataChangedInfo === null || dataChangedInfo === void 0 ? void 0 : dataChangedInfo.cellDataChangedInfo,
+                gridDataChangedInfo: dataChangedInfo === null || dataChangedInfo === void 0 ? void 0 : dataChangedInfo.gridDataChangedInfo,
+            });
+            if (returnText) {
+                return returnText;
+            }
+        }
+        if (alertDefinition.MessageHeader) {
+            return alertDefinition.MessageHeader;
+        }
+        return null;
+    }
+    /**
+     * Returns a description of an Alert Definition's Rule
+     * @param alertDefinition Alert Definition to use
+     */
+    getAlertRuleDescription(alertDefinition) {
+        var _a, _b, _c, _d;
+        let ruleDescription = ((_b = (_a = alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.length)
+            ? (_d = (_c = alertDefinition.Rule) === null || _c === void 0 ? void 0 : _c.Predicates) === null || _d === void 0 ? void 0 : _d.map((predicate) => this.getPredicateApi().predicateToString(predicate)).join(' AND ')
+            : this.adaptable.api.internalApi.getAdaptableQueryExpressionText(alertDefinition.Rule);
+        return ruleDescription;
+    }
+    /**
+     * Was Adaptable Alert fired due to a Cell Change
+     * @param alert AdaptableAlert to check
+     */
+    isCellChangedAdaptableAlert(alert) {
+        return alert.alertType === 'cellChanged';
+    }
+    /**
+     * Was Adaptable Alert fired due to a Row Change
+     * @param alert AdaptableAlert to check
+     */
+    isRowChangedAdaptableAlert(alert) {
+        return alert.alertType === 'rowChanged';
+    }
+    /**
+     * Is Adaptable Alert a Generic one
+     * @param alert AdaptableAlert to check
+     */
+    isGenericAdaptableAlert(alert) {
+        return alert.alertType === 'generic';
+    }
+    /**
+     * Returns for the Alert Type for an Adaptable Alert
+     * @param alert AdaptableAlert to check
+     */
+    getAlertTypeForAdaptableAlert(alert) {
+        return alert.alertType;
+    }
+    getAdaptableFormFromAlertForm(alertForm, context, defaultMessageType) {
+        var _a, _b;
+        const api = this.adaptable.api;
+        let adaptableAlertForm;
+        let isActionForm = false;
+        if (typeof alertForm === 'string') {
+            const alertForms = this.getAlertOptions().alertForms || [];
+            adaptableAlertForm = (_a = alertForms.find((f) => f.name === alertForm)) === null || _a === void 0 ? void 0 : _a.form;
+        }
+        else {
+            adaptableAlertForm = Object.assign(Object.assign({}, alertForm), { buttons: (alertForm.Buttons || []).map((alertButton) => {
+                    return Object.assign(Object.assign({}, alertButton), { onClick: () => {
+                            api.alertApi.internalApi.executeAlertButton(alertButton, context);
+                        } });
+                }) });
+            isActionForm = true;
+        }
+        if (!adaptableAlertForm) {
+            return;
+        }
+        if (adaptableAlertForm && adaptableAlertForm.buttons) {
+            // dont mutate the form, but clone it
+            adaptableAlertForm = Object.assign({}, adaptableAlertForm);
+            adaptableAlertForm.buttons = (_b = adaptableAlertForm.buttons) === null || _b === void 0 ? void 0 : _b.map((button) => {
+                let buttonStyle = isActionForm
+                    ? button.ButtonStyle
+                    : this.getAdaptableApi().internalApi.getStyleForButton(button, context);
+                if (defaultMessageType && !(buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone)) {
+                    // force the button tone to be the alert tone, if the tone is missing from button style (or button style non-existent)
+                    buttonStyle = Object.assign(Object.assign({}, buttonStyle), { tone: defaultMessageType.toLowerCase() });
+                }
+                let label = isActionForm
+                    ? button.Label
+                    : this.getAdaptableApi().internalApi.getLabelForButton(button, context);
+                return Object.assign(Object.assign({}, button), { buttonStyle,
+                    label });
+            });
+        }
+        return adaptableAlertForm;
+    }
+    getAdaptableAlerts() {
+        var _a;
+        return (_a = this.getAdaptableState().System.AdaptableAlerts) !== null && _a !== void 0 ? _a : [];
+    }
+    getAdaptableCellChangedAlerts() {
+        return this.getAdaptableAlerts().filter(AdaptableAlert_1.isAdaptableCellChangedAlert);
+    }
+    getAdaptableRowChangedAlerts() {
+        return this.getAdaptableAlerts().filter(AdaptableAlert_1.isAdaptableRowChangedAlert);
+    }
+    getAdaptableAlertWithHighlightCell(columnId, rowNode) {
+        // only alerts triggered by cell changes are relevant for HighlightCell actions
+        return this.getAdaptableCellChangedAlerts().find((alert) => {
+            var _a, _b, _c, _d;
+            return ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightCell) &&
+                ((_c = (_b = alert.cellDataChangedInfo) === null || _b === void 0 ? void 0 : _b.column) === null || _c === void 0 ? void 0 : _c.columnId) === columnId &&
+                ((_d = alert.cellDataChangedInfo) === null || _d === void 0 ? void 0 : _d.rowNode) === rowNode;
+        });
+    }
+    getAdaptableAlertWithHighlightRow(rowNode) {
+        let alertWithRowHighlight;
+        alertWithRowHighlight = this.getAdaptableRowChangedAlerts().find((alert) => {
+            var _a, _b;
+            if ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightRow) {
+                if ((_b = alert.gridDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowNodes.map((rowNode) => rowNode.id).includes(rowNode.id)) {
+                    return alert;
+                }
+            }
+        });
+        if (alertWithRowHighlight) {
+            return alertWithRowHighlight;
+        }
+        alertWithRowHighlight = this.getAdaptableCellChangedAlerts().find((alert) => {
+            var _a, _b;
+            if ((_a = alert.alertDefinition.AlertProperties) === null || _a === void 0 ? void 0 : _a.HighlightRow) {
+                if (((_b = alert.cellDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowNode.id) == rowNode.id) {
+                    return alert;
+                }
+            }
+        });
+        return alertWithRowHighlight;
+    }
+    isAlertDefinitionForAddedRowChangeEvent(alertDefinition) {
+        var _a, _b, _c;
+        const addedRowPredicate = 'AddedRow';
+        return (_c = (_b = (_a = alertDefinition === null || alertDefinition === void 0 ? void 0 : alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.some) === null || _c === void 0 ? void 0 : _c.call(_b, (predicate) => predicate.PredicateId === addedRowPredicate);
+    }
+    isAlertDefinitionForRemovedRowChangeEvent(alertDefinition) {
+        var _a, _b, _c;
+        const removedRowPredicate = 'RemovedRow';
+        return (_c = (_b = (_a = alertDefinition === null || alertDefinition === void 0 ? void 0 : alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.some) === null || _c === void 0 ? void 0 : _c.call(_b, (predicate) => predicate.PredicateId === removedRowPredicate);
+    }
+    getAlertDefinitionsForCellDataChange(dataChangedEvent) {
+        const allActiveNonReactiveDefinitions = this.getAdaptableApi().alertApi.internalApi.getActiveNonReactiveAlertDefinitions();
+        let relatedAlertDefinitions = allActiveNonReactiveDefinitions
+            .filter((v) => this.getAdaptableApi().scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
+            .filter((alertDefinition) => !(0, AdaptableQuery_1.isReactiveQuery)(alertDefinition.Rule));
+        let triggeredAlerts = [];
+        if (ArrayExtensions_1.default.IsNotNullOrEmpty(relatedAlertDefinitions)) {
+            relatedAlertDefinitions.forEach((alertDefinition) => {
+                if (alertDefinition.Rule.BooleanExpression) {
+                    let expression = alertDefinition.Rule.BooleanExpression;
+                    let rowNode = dataChangedEvent.rowNode;
+                    if (!rowNode) {
+                        rowNode = this.getAdaptableApi().gridApi.getRowNodeForPrimaryKey(dataChangedEvent.primaryKeyValue);
+                    }
+                    const isValidExpression = this.getAdaptableApi().queryLanguageApi.isValidBooleanExpression(expression, 'Alert', `Invalid Alert boolean expression '${expression}'`);
+                    const isSatisfiedExpression = isValidExpression &&
+                        this.getAdaptableApi()
+                            .internalApi.getQueryLanguageService()
+                            .evaluateBooleanExpression(expression, 'Alert', rowNode);
+                    if (isSatisfiedExpression) {
+                        triggeredAlerts.push(alertDefinition);
+                    }
+                }
+                else if (alertDefinition.Rule.AggregatedBooleanExpression) {
+                    const isValidExpression = this.getAdaptableApi().queryLanguageApi.isValidAggregatedBooleanExpression(alertDefinition.Rule.AggregatedBooleanExpression, 'Alert', `Invalid Alert boolean expression '${alertDefinition.Rule.AggregatedBooleanExpression}'`);
+                    const isSatisfiedExpression = isValidExpression &&
+                        this.isAggregationAlertTriggered(alertDefinition, dataChangedEvent);
+                    if (isSatisfiedExpression) {
+                        triggeredAlerts.push(alertDefinition);
+                    }
+                }
+                else {
+                    if (!this.isAlertDefinitionForRowChangeEvent(alertDefinition) &&
+                        this.isAlertPredicateTriggered(alertDefinition, dataChangedEvent)) {
+                        triggeredAlerts.push(alertDefinition);
+                    }
+                }
+            });
+        }
+        return triggeredAlerts;
+    }
+    isAggregationAlertTriggered(alertDefinition, dataChangedEvent) {
+        const changedColumn = dataChangedEvent.column.columnId;
+        const aggregationColumns = this.getAdaptableApi().queryLanguageApi.getColumnsFromExpression(alertDefinition.Rule.AggregatedBooleanExpression);
+        if (!aggregationColumns.includes(changedColumn)) {
+            return false;
+        }
+        const aggregatedBooleanValue = this.getAdaptableApi()
+            .internalApi.getQueryLanguageService()
+            .computeAggregatedBooleanValue(alertDefinition.Rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
+        return aggregatedBooleanValue;
+    }
+    isAlertPredicateTriggered(alert, dataChangedEvent, defaultNoPredicateReturn = false) {
+        var _a;
+        return this.getAdaptableApi().predicateApi.handlePredicates((_a = alert.Rule) === null || _a === void 0 ? void 0 : _a.Predicates, {
+            value: dataChangedEvent.newValue,
+            oldValue: dataChangedEvent.oldValue,
+            // TODO send real display value
+            displayValue: null,
+            node: dataChangedEvent.rowNode,
+            column: dataChangedEvent.column,
+        }, defaultNoPredicateReturn);
+    }
+    isAlertDefinitionForRowChangeEvent(alertDefinition) {
+        return (this.isAlertDefinitionForAddedRowChangeEvent(alertDefinition) ||
+            this.isAlertDefinitionForRemovedRowChangeEvent(alertDefinition));
+    }
+    showAlertForDefinitions(cellDataChangedInfo, alertDefinitions = []) {
+        alertDefinitions.forEach((alertDefinition) => {
+            const alert = ObjectFactory_1.default.CreateCellChangedAlert(this.getAdaptableApi().alertApi.internalApi.getAlertMessageTitle(alertDefinition, cellDataChangedInfo), this.getAdaptableApi().alertApi.internalApi.getAlertDescription(alertDefinition, cellDataChangedInfo), alertDefinition, cellDataChangedInfo);
+            this.getAdaptableApi().alertApi.showAdaptableAlert(alert);
+        });
+    }
+}
+exports.AlertInternalApi = AlertInternalApi;

package/src/Api/Internal/CalculatedColumnInternalApi.d.ts

@@ -0,0 +1,24 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
+export declare class CalculatedColumnInternalApi extends ApiBase {
+    /**
+     * Returns all the references in the AdaptableState of the given CalculatedColumn
+     * @param calculatedColumn CalculatedColumn to be checked
+     */
+    getCalculatedColumnModuleReferences(calculatedColumn: CalculatedColumn): string[];
+    /**
+     * Returns all Calculated Columns whose Expression contains the ColumnId
+     * @param columnId ColumnId to check
+     */
+    getCalculatedColumnsReferencingColumnId(columnId: string): CalculatedColumn[];
+    /**
+     * Gets any ColumnIds referenced in a Calculated Column
+     * @param calculatedColumn Calculated Column to check
+     */
+    getReferencedColumnIdsForCalculatedColumn(calculatedColumn: CalculatedColumn): string[];
+    /**
+     * Gets any ColumnIds referenced in a Calculated Column
+     * @param calculatedColumnId CalculatedColumnId to check
+     */
+    getReferencedColumnIdsForCalculatedColumnId(calculatedColumnId: string): string[];
+}