@adaptabletools/adaptable 24.0.0-canary.3 → 24.0.0-canary.5

package/aql.d.ts

@@ -0,0 +1,104 @@
+import type { AdaptableColumnDataType } from './src/AdaptableState/Common/AdaptableColumn';
+import type { AdaptableStandardExpressionModule } from './src/AdaptableState/Common/Types';
+import { type LegacyExpressionKind } from './src/aql/legacyExpressionKinds';
+/**
+ * What an Expression returns, and whether it is evaluated per row or across rows:
+ * - `boolean` - Standard boolean Expressions: Grid Filter, Column Filter, Format Column,
+ *   Alert and Flashing Cell rules, Named Queries, Reports; also Relative Change
+ *   (`ANY_CHANGE()`) and boolean Observable rules (`CHANGE_COUNT{[price], WITHIN(5m)} >= 2`)
+ * - `scalar` - Standard Expressions returning a value: Calculated Columns, scalar Named
+ *   Queries; also Observable values (`MAX{[price], WITHIN(1d)}`)
+ * - `aggregatedScalar` - Aggregation Expressions in Calculated Columns (`SUM{[price]}`),
+ *   including Cumulative, Quantile and Window Expressions (`LAG{[price], 1, OVER([date])}`)
+ * - `aggregatedBoolean` - Aggregation rules in Alerts (`SUM{[price]} > 100`)
+ *
+ * Which of these a Module accepts, and which Functions it offers, is checked
+ * when `module` is passed to {@link validateExpression}.
+ */
+export type AdaptableQLExpressionKind = LegacyExpressionKind;
+export interface ValidateExpressionOptions {
+    kind: AdaptableQLExpressionKind;
+    /**
+     * Module the Expression belongs to. Applies that Module's rules: Observable
+     * Functions only in Alert, Calculated Column, Format Column and Flashing
+     * Cell; Relative Change Functions only in Alert and Flashing Cell;
+     * Cumulative and Window Functions only in Calculated Columns; aggregated
+     * kinds only in the Modules that evaluate them. When omitted, every
+     * system Function is accepted.
+     */
+    module?: AdaptableStandardExpressionModule;
+    /**
+     * Column Id to AdapTable data type. When provided, references to other
+     * Columns are errors and Column types are checked against Function inputs.
+     */
+    columns?: Record<string, AdaptableColumnDataType | undefined>;
+}
+export interface ExpressionValidationIssue {
+    /** Stable identifier, e.g. `AQL_LEGACY_SPELLING`; absent for generic type errors */
+    code?: string;
+    message: string;
+    severity: 'error' | 'warning' | 'info';
+    /** Character range in the Expression `[start, end)` */
+    range?: [number, number];
+    /** Suggested rewrite, when one exists */
+    quickFix?: {
+        label: string;
+        replacement: string;
+        range?: [number, number];
+    };
+}
+export interface ExpressionValidationResult {
+    isValid: boolean;
+    issues: ExpressionValidationIssue[];
+}
+export interface MigrateExpressionResult {
+    /** Current-syntax Expression, or the input unchanged when it does not parse */
+    expression: string;
+    changed: boolean;
+    /** Set when the input does not parse */
+    error?: string;
+    /** How a rewritten legacy observable rule differs in meaning from the original */
+    notes?: string[];
+}
+export interface ExpressionFunctionDescription {
+    name: string;
+    /** `paren` is `NAME(...)`, `brace` is `NAME{...}` */
+    callForm: 'paren' | 'brace';
+    group: 'scalar' | 'aggregation' | 'observable' | 'clause';
+    returnType?: string;
+    description?: string;
+    signatures: string[];
+    examples: string[];
+    category?: string;
+}
+/**
+ * Validates an AdapTableQL Expression without a grid. Mirrors
+ * `ExpressionApi.isValidBooleanExpression` / `isValidScalarExpression` /
+ * `isValidAggregatedScalarExpression` / `isValidAggregatedBooleanExpression`,
+ * but reports every issue (with ranges and quick fixes) instead of the first.
+ *
+ * Pre-v24 spellings (`CUMUL(...)`, `TIMEFRAME(...)`, paren aggregations) are
+ * errors; convert them with {@link migrateExpression} first.
+ */
+export declare function validateExpression(expressionInput: string, options: ValidateExpressionOptions): ExpressionValidationResult;
+/**
+ * Converts a pre-v24 AdapTableQL Expression to the current syntax: brace
+ * aggregations (`SUM{[price]}`), named operands (`CUMULATIVE(...)`,
+ * `WITHIN(5m)`), no `CUMUL(...)` / `TIMEFRAME(...)` wrappers. Same logic as
+ * `ExpressionApi.migratePreV24Expression`.
+ *
+ * Pass `kind` for single-argument dual names: `SUM([x])` is an aggregation
+ * in the aggregated kinds and a row-wise scalar elsewhere.
+ *
+ * Legacy observable rules (`ROW_CHANGE(COUNT([price], 3), TIMEFRAME('5m'))`)
+ * are rewritten to observable calls (`CHANGE_COUNT{[price], WITHIN(5m)} >= 3`),
+ * as the State upgrade does for Alerts.
+ */
+export declare function migrateExpression(expression: string, options?: {
+    kind?: AdaptableQLExpressionKind;
+}): MigrateExpressionResult;
+/**
+ * Every system Expression Function, aggregation, observable function and
+ * clause, with its signatures and examples.
+ */
+export declare function getExpressionFunctionCatalogue(): ExpressionFunctionDescription[];

package/aql.js

@@ -0,0 +1,212 @@
+import { CLAUSE_DOCS, SYSTEM_AGGREGATION_CATALOGUE, compileValueExpression, isAST_Function, mapDataTypeToStaticType, migrateExpression as migrateAqlExpression, normalizeAst, parse, validateAqlExpression, validateExpressionTypes, } from "./vendor/aql/index.js";
+import { AGGREGATED_BOOLEAN_MODULES, moduleAllowsObservableCalls, } from './src/aql/expressionFunctionAvailability';
+import { getMissingColumnIssues } from './src/aql/getMissingColumnIssues';
+import { mapLegacyKindToValidationRequest, toMigrateOptions, } from './src/aql/legacyExpressionKinds';
+import { systemAggregatedExpressionFunctions, systemAggregationClauseFunctions, systemObservableExpressionFunctions, systemScalarExpressionFunctions, } from './src/aql/systemExpressionFunctions';
+const scalarFunctions = {
+    ...systemObservableExpressionFunctions,
+    ...systemScalarExpressionFunctions,
+};
+const isAggregatedKind = (kind) => kind === 'aggregatedScalar' || kind === 'aggregatedBoolean';
+const AGGREGATED_KIND_MODULES = {
+    aggregatedScalar: ['CalculatedColumn'],
+    aggregatedBoolean: AGGREGATED_BOOLEAN_MODULES,
+};
+const scalarPool = systemScalarExpressionFunctions;
+const aggregationPool = {
+    ...systemAggregatedExpressionFunctions,
+    ...systemAggregationClauseFunctions,
+};
+function getModuleAvailabilityIssues(ast, module, aggregated) {
+    const issues = [];
+    const reported = new Set();
+    const visit = (node) => {
+        if (node == null || typeof node !== 'object') {
+            return;
+        }
+        if (Array.isArray(node)) {
+            node.forEach(visit);
+            return;
+        }
+        if (!isAST_Function(node)) {
+            Object.values(node).forEach(visit);
+            return;
+        }
+        const fn = node;
+        const kind = fn.kind ?? fn.metaInfo;
+        if (kind === 'OBSERVABLE_CALL') {
+            return;
+        }
+        const scalar = kind === 'FUNCTION' ? scalarPool[fn.type] : undefined;
+        const modules = (scalar ?? (aggregated ? aggregationPool[fn.type] : undefined))?.isAvailable;
+        if (Array.isArray(modules) && !modules.includes(module)) {
+            if (!reported.has(fn.type)) {
+                reported.add(fn.type);
+                issues.push({
+                    code: 'AQL_NOT_AVAILABLE_IN_MODULE',
+                    message: `${fn.type} is not available in ${module} Expressions (only in ${modules.join(', ')})`,
+                    severity: scalar ? 'error' : 'warning',
+                    range: fn.range,
+                });
+            }
+            return;
+        }
+        fn.args.forEach(visit);
+    };
+    visit(ast);
+    return issues;
+}
+const error = (message, code) => ({
+    code,
+    message,
+    severity: 'error',
+});
+const toResult = (issues) => {
+    const byKey = new Map();
+    for (const issue of issues) {
+        const key = `${issue.message}::${issue.range?.join(',') ?? ''}`;
+        if (!byKey.get(key)?.code) {
+            byKey.set(key, issue);
+        }
+    }
+    const unique = [...byKey.values()];
+    return {
+        isValid: !unique.some((issue) => issue.severity === 'error'),
+        issues: unique,
+    };
+};
+export function validateExpression(expressionInput, options) {
+    const expression = (expressionInput ?? '').trim();
+    if (expression === '') {
+        return toResult([error(`empty ${options.kind} expression`, 'AQL_EMPTY')]);
+    }
+    let ast;
+    try {
+        ast = parse(expression).ast;
+    }
+    catch (e) {
+        return toResult([error(e instanceof Error ? e.message : String(e), 'AQL_PARSE_ERROR')]);
+    }
+    const columns = options.columns;
+    const getColumnType = columns
+        ? (columnId) => mapDataTypeToStaticType(columns[columnId])
+        : undefined;
+    const issues = [];
+    if (!isAggregatedKind(options.kind)) {
+        const rootFn = ast[ast.length - 1];
+        if (rootFn?.type === undefined || scalarFunctions[rootFn.type] === undefined) {
+            return toResult([
+                error(`provided function ${rootFn?.type} cannot be handled`, 'AQL_UNKNOWN_FUNCTION'),
+            ]);
+        }
+        const typeCheck = validateExpressionTypes(ast, scalarFunctions, {
+            getBraceCallSpec: SYSTEM_AGGREGATION_CATALOGUE.getBraceCallSpec,
+            getColumnType,
+        });
+        issues.push(...typeCheck.issues);
+    }
+    const { module } = options;
+    let kindInModule = true;
+    if (module && isAggregatedKind(options.kind)) {
+        const modules = AGGREGATED_KIND_MODULES[options.kind];
+        kindInModule = modules.includes(module);
+        if (!kindInModule) {
+            issues.push(error(`${module} does not evaluate ${options.kind} Expressions (only ${modules.join(', ')} does)`, 'AQL_KIND_NOT_IN_MODULE'));
+        }
+    }
+    const structure = validateAqlExpression(ast, {
+        request: {
+            ...mapLegacyKindToValidationRequest(options.kind),
+            requiresAggCalls: false,
+            allowsObservableCalls: module ? moduleAllowsObservableCalls(module) : true,
+        },
+        scalarFunctions,
+        catalogue: SYSTEM_AGGREGATION_CATALOGUE,
+        getColumnType,
+    });
+    issues.push(...structure.issues);
+    if (module && kindInModule) {
+        issues.push(...getModuleAvailabilityIssues(structure.normalizedAst, module, isAggregatedKind(options.kind)));
+    }
+    if (columns) {
+        issues.push(...getMissingColumnIssues(ast, (columnId) => columnId in columns).map((issue) => ({
+            ...issue,
+            code: 'AQL_UNKNOWN_COLUMN',
+        })));
+    }
+    if (isAggregatedKind(options.kind) && !issues.some((issue) => issue.severity === 'error')) {
+        const mismatch = error(`provided ${options.kind} expression does not evaluate to a supported aggregation`, 'AQL_AGG_REQUIRED');
+        try {
+            const compiled = compileValueExpression(normalizeAst(ast), {
+                registry: SYSTEM_AGGREGATION_CATALOGUE,
+                getColumnType,
+                scalarFunctions: systemScalarExpressionFunctions,
+            });
+            const isBoolean = compiled.outputType === 'boolean';
+            if (compiled.aggregations.length === 0 ||
+                (options.kind === 'aggregatedBoolean' && !isBoolean) ||
+                (options.kind === 'aggregatedScalar' && isBoolean)) {
+                issues.push(mismatch);
+            }
+        }
+        catch (e) {
+            issues.push(error(e instanceof Error ? e.message : String(e)));
+        }
+    }
+    return toResult(issues);
+}
+export function migrateExpression(expression, options) {
+    const result = migrateAqlExpression((expression ?? '').trim(), {
+        ...toMigrateOptions(options?.kind),
+        rewriteLegacyObservables: true,
+    });
+    return {
+        expression: result.expression,
+        changed: result.changed,
+        ...(result.error !== undefined ? { error: result.error } : {}),
+        ...(result.notes?.length ? { notes: result.notes.map((note) => note.message) } : {}),
+    };
+}
+export function getExpressionFunctionCatalogue() {
+    const scalar = Object.entries(systemScalarExpressionFunctions).map(([name, fn]) => ({
+        name,
+        callForm: 'paren',
+        group: 'scalar',
+        returnType: fn.returnType,
+        description: fn.description,
+        signatures: fn.signatures ?? [],
+        examples: fn.examples ?? [],
+        category: fn.category,
+    }));
+    const aggregations = SYSTEM_AGGREGATION_CATALOGUE.callables()
+        .filter((callable) => callable.system)
+        .map((callable) => ({
+        name: callable.name,
+        callForm: callable.callForm,
+        group: 'aggregation',
+        description: callable.docs.description,
+        signatures: callable.docs.signatures ?? [],
+        examples: callable.docs.examples ?? [],
+        category: callable.docs.category,
+    }));
+    const observables = Object.entries(systemObservableExpressionFunctions).map(([name, fn]) => ({
+        name,
+        callForm: 'brace',
+        group: 'observable',
+        returnType: fn.returnType,
+        description: fn.description,
+        signatures: fn.signatures ?? [],
+        examples: fn.examples ?? [],
+        category: fn.category,
+    }));
+    const clauses = Object.entries(CLAUSE_DOCS).map(([name, docs]) => ({
+        name,
+        callForm: 'paren',
+        group: 'clause',
+        description: docs.description,
+        signatures: docs.signatures,
+        examples: docs.examples,
+        category: docs.category,
+    }));
+    return [...scalar, ...aggregations, ...observables, ...clauses];
+}

package/package.json

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

package/src/AdaptableState/Common/AdaptableAlert.d.ts

@@ -21,8 +21,18 @@ export interface AdaptableGenericAlert extends AdaptableAlertBase<'generic'> {
 export interface AdaptableCellChangedAlert<TData = any> extends AdaptableAlertBase<'cellChanged'> {
     /**
      * Cell DataChange which triggered Alert
+     *
+     * For a consolidated batch Alert this is the first affected cell (jump-to-cell lands here).
      */
     cellDataChangedInfo: CellDataChangedInfo<TData>;
+    /**
+     * All cell changes represented by this Alert when several changes from one batch
+     * action were consolidated (`occurrenceCount` > 1). The first entry matches
+     * {@link AdaptableCellChangedAlert.cellDataChangedInfo}.
+     *
+     * Used so cell / row highlighting still applies to every affected cell.
+     */
+    cellDataChangedInfos?: CellDataChangedInfo<TData>[];
 }
 /**
  * Defines an Alert fired by AdapTable when a row is changed
@@ -64,3 +74,8 @@ export interface AdaptableAlertBase<T> extends Identifiable {
 }
 export declare const isAdaptableCellChangedAlert: (alert: AdaptableAlert) => alert is AdaptableCellChangedAlert;
 export declare const isAdaptableRowChangedAlert: (alert: AdaptableAlert) => alert is AdaptableRowChangedAlert;
+/**
+ * Cell changes to highlight (or clear) for an Alert: every cell in a
+ * consolidated batch, otherwise the single {@link AdaptableCellChangedAlert.cellDataChangedInfo}.
+ */
+export declare const getAlertCellDataChangedInfos: (alert: AdaptableAlert) => CellDataChangedInfo[];

package/src/AdaptableState/Common/AdaptableAlert.js

@@ -4,3 +4,12 @@ export const isAdaptableCellChangedAlert = (alert) => {
 export const isAdaptableRowChangedAlert = (alert) => {
     return alert.alertType === 'rowChanged';
 };
+export const getAlertCellDataChangedInfos = (alert) => {
+    if (!isAdaptableCellChangedAlert(alert)) {
+        return [];
+    }
+    if (alert.cellDataChangedInfos?.length) {
+        return alert.cellDataChangedInfos;
+    }
+    return alert.cellDataChangedInfo ? [alert.cellDataChangedInfo] : [];
+};

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

@@ -17,11 +17,13 @@ export interface LayoutChangedInfo extends BaseContext {
      */
     newLayoutState: LayoutState;
     /**
-     * Facets of the **current** Layout that changed.
+     * Which parts of the **current** Layout changed.
+     *
+     * Use this when you care *what* changed, rather than which `actionName` fired:
      *
      * - `LAYOUT_SAVE`: diffs non-filter facets (e.g. `ColumnSorting`, `RowGrouping`)
-     * - Column Filter actions: `['ColumnFilter']`
-     * - Grid Filter actions: `['GridFilter']`
+     * - Column Filter actions: always `['ColumnFilter']`
+     * - Grid Filter actions: always `['GridFilter']`
      *
      * Omitted for layout identity changes (`LAYOUT_SELECT`, `LAYOUT_ADD`, `LAYOUT_DELETE`, `LAYOUT_READY`).
      */

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

@@ -38,10 +38,9 @@ export declare class AlertApiImpl extends ApiBase implements AlertApi {
     private applyPerChangeAlertEffects;
     /**
      * Effects that should only happen once for a given Alert: adding the Alert to the store (so it
-     * shows in the toolbar/status bar), the toast notification, jumping to the cell/row and
-     * highlighting the cell/row (which reads the highlight from the just-stored Alert). When Alerts
-     * are consolidated these run a single time for the consolidated Alert, jumping to / highlighting
-     * the first affected cell/row.
+     * shows in the toolbar/status bar), the toast notification and jumping to the cell/row.
+     * Highlighting reads the just-stored Alert and is applied to every cell in
+     * `cellDataChangedInfos` when the Alert is a consolidated batch.
      */
     private applyOnceAlertEffects;
     /**
@@ -69,7 +68,8 @@ export declare class AlertApiImpl extends ApiBase implements AlertApi {
     /**
      * Builds a single consolidated Alert from a group of Alerts fired by the same Alert Definition.
      * The representative (first) Alert's context is retained (so jump-to-cell lands on the first
-     * affected cell) and an occurrence count / summary message is applied.
+     * affected cell) and an occurrence count / summary message is applied. Every cell change is
+     * kept on `cellDataChangedInfos` so highlighting still covers the whole batch.
      *
      * When every Alert in the group shares the same message (typical for a Bulk Update that sets the
      * same value across cells), we keep that message and append the "N cells triggered this Alert"

package/src/Api/Implementation/AlertApiImpl.js

@@ -4,7 +4,7 @@ import * as AlertRedux from '../../Redux/ActionsReducers/AlertRedux';
 import { ApiBase } from './ApiBase';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import ObjectFactory from '../../Utilities/ObjectFactory';
-import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
+import { getAlertCellDataChangedInfos, isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { AlertInternalApi } from '../Internal/AlertInternalApi';
 import { resolveContainerElement } from '../../Utilities/resolveContainerElement';
@@ -100,26 +100,29 @@ export class AlertApiImpl extends ApiBase {
                 this.getGridApi().jumpToRow(firstRowNode);
             }
         }
-        if (isAdaptableCellChangedAlert(alertToShow) &&
-            alertToShow.cellDataChangedInfo &&
+        const highlightCellChanges = getAlertCellDataChangedInfos(alertToShow);
+        if (highlightCellChanges.length &&
             (alertProperties.HighlightCell || alertProperties.HighlightRow)) {
-            let alertNode = alertToShow.cellDataChangedInfo.rowNode;
-            if (!alertNode) {
-                alertNode = this.getGridApi().getRowNodeForPrimaryKey(alertToShow.cellDataChangedInfo.primaryKeyValue);
-            }
-            if (alertNode) {
-                if (alertProperties.HighlightRow) {
-                    this.getGridApi().refreshRowNodes([alertNode]);
-                    setTimeout(() => {
-                        this.dispatchAction(InternalRedux.AdaptableAlertRemoveRowHighlight(alertToShow));
-                    }, this.getAlertOptions().rowHighlightDuration);
-                }
-                if (alertProperties.HighlightCell && alertToShow.cellDataChangedInfo.column) {
-                    this.getGridApi().refreshCell(alertNode, alertToShow.cellDataChangedInfo.column.columnId);
-                    setTimeout(() => {
-                        this.dispatchAction(InternalRedux.AdaptableAlertRemoveCellHighlight(alertToShow));
-                    }, this.getAlertOptions().cellHighlightDuration);
+            const highlightNodes = [];
+            highlightCellChanges.forEach((cellChange) => {
+                const alertNode = cellChange.rowNode ?? this.getGridApi().getRowNodeForPrimaryKey(cellChange.primaryKeyValue);
+                if (alertNode) {
+                    highlightNodes.push(alertNode);
+                    if (alertProperties.HighlightCell && cellChange.column) {
+                        this.getGridApi().refreshCell(alertNode, cellChange.column.columnId);
+                    }
                 }
+            });
+            if (alertProperties.HighlightRow && highlightNodes.length) {
+                this.getGridApi().refreshRowNodes(highlightNodes);
+                setTimeout(() => {
+                    this.dispatchAction(InternalRedux.AdaptableAlertRemoveRowHighlight(alertToShow));
+                }, this.getAlertOptions().rowHighlightDuration);
+            }
+            if (alertProperties.HighlightCell) {
+                setTimeout(() => {
+                    this.dispatchAction(InternalRedux.AdaptableAlertRemoveCellHighlight(alertToShow));
+                }, this.getAlertOptions().cellHighlightDuration);
             }
         }
         else if (alertProperties.HighlightRow &&
@@ -188,10 +191,14 @@ export class AlertApiImpl extends ApiBase {
         const message = allSameMessage && StringExtensions.IsNotNullOrEmpty(representative.message)
             ? `${representative.message}\n${summaryMessage}`
             : summaryMessage;
+        const cellDataChangedInfos = group.flatMap((alert) => getAlertCellDataChangedInfos(alert));
         return {
             ...representative,
             occurrenceCount: count,
             message,
+            ...(isAdaptableCellChangedAlert(representative) && cellDataChangedInfos.length
+                ? { cellDataChangedInfos }
+                : {}),
         };
     }
     displayAdaptableAlertNotification(alert) {

package/src/Api/Internal/AlertInternalApi.js

@@ -1,6 +1,6 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { expressionKindForAlertType, isRowChangeAlertDefinition, } from '../../AdaptableState/AlertState';
-import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
+import { getAlertCellDataChangedInfos, isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { AlertModuleId } from '../../Utilities/Constants/ModuleConstants';
 import ObjectFactory from '../../Utilities/ObjectFactory';
@@ -476,9 +476,16 @@ export class AlertInternalApi extends ApiBase {
         return this.getAdaptableAlerts().filter(isAdaptableRowChangedAlert);
     }
     getAdaptableAlertWithHighlightCell(columnId, rowNode) {
-        return this.getAdaptableCellChangedAlerts().find((alert) => getRuleAlertProperties(alert.alertDefinition)?.HighlightCell &&
-            alert.cellDataChangedInfo?.column?.columnId === columnId &&
-            alert.cellDataChangedInfo?.rowNode === rowNode);
+        const primaryKeyValue = this.getGridApi().getPrimaryKeyValueForRowNode(rowNode);
+        return this.getAdaptableCellChangedAlerts().find((alert) => {
+            if (!getRuleAlertProperties(alert.alertDefinition)?.HighlightCell) {
+                return false;
+            }
+            return getAlertCellDataChangedInfos(alert).some((cellChange) => cellChange.column?.columnId === columnId &&
+                (cellChange.rowNode === rowNode ||
+                    cellChange.rowNode?.id === rowNode.id ||
+                    (primaryKeyValue != null && cellChange.primaryKeyValue === primaryKeyValue)));
+        });
     }
     getAdaptableAlertWithHighlightRow(rowNode) {
         let alertWithRowHighlight;
@@ -494,9 +501,7 @@ export class AlertInternalApi extends ApiBase {
         }
         alertWithRowHighlight = this.getAdaptableCellChangedAlerts().find((alert) => {
             if (getRuleAlertProperties(alert.alertDefinition)?.HighlightRow) {
-                if (alert.cellDataChangedInfo?.rowNode.id == rowNode.id) {
-                    return alert;
-                }
+                return getAlertCellDataChangedInfos(alert).some((cellChange) => cellChange.rowNode?.id == rowNode.id);
             }
         });
         return alertWithRowHighlight;

package/src/Redux/ActionsReducers/LayoutRedux.d.ts

@@ -4,7 +4,7 @@ import { LayoutState, Layout } from '../../AdaptableState/LayoutState';
 import { ColumnFilter } from '../../types';
 import { LayoutExtensionInfo, LayoutExtensionModule } from '../../AdaptableState/Common/ExtendedLayout';
 /**
- * @ReduxAction Layout Module is ready
+ * @ReduxAction Layout Module is ready — fired once after AdapTable starts, for the Layout that is already current
  */
 export declare const LAYOUT_READY = "LAYOUT_READY";
 /**
@@ -20,11 +20,11 @@ export declare const LAYOUT_EDIT = "LAYOUT_EDIT";
  */
 export declare const LAYOUT_DELETE = "LAYOUT_DELETE";
 /**
- * @ReduxAction A Layout has been selected
+ * @ReduxAction A different Layout has been selected
  */
 export declare const LAYOUT_SELECT = "LAYOUT_SELECT";
 /**
- * @ReduxAction A Layout has been (auto)saved
+ * @ReduxAction A Layout has been saved, including auto-save after grid edits (sort, grouping, columns, and so on)
  */
 export declare const LAYOUT_SAVE = "LAYOUT_SAVE";
 /**

package/src/Redux/Store/AdaptableStore.js

@@ -5,7 +5,7 @@ import { PROGRESS_INDICATOR_HIDE, PROGRESS_INDICATOR_SHOW } from '../ActionsRedu
 import { createEngine as createEngineLocal } from './AdaptableReduxLocalStorageEngine';
 import { mergeReducer } from './AdaptableReduxMerger';
 import { isRowChangeAlertDefinition } from '../../AdaptableState/AlertState';
-import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
+import { getAlertCellDataChangedInfos, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
 import { closeAgChartDefinitionIfOpen, closeExternalChartDefinitionIfOpen, } from '../../Utilities/Helpers/ChartHelper';
 import { refreshScheduledAlertJobs, refreshScheduledReportJobs, } from '../../Utilities/Helpers/Scheduling/ScheduledJobsMiddlewareHelper';
 import { getRuleAlertProperties, isScheduledAlertDefinition, } from '../../Utilities/Helpers/Scheduling/ScheduledAlertHelper';
@@ -712,11 +712,12 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const actionTyped = action;
                     let ret = next(action);
                     const adaptableAlert = actionTyped.alert;
-                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightCell &&
-                        isAdaptableCellChangedAlert(adaptableAlert) &&
-                        adaptableAlert.cellDataChangedInfo) {
-                        const rowNode = adaptableAlert.cellDataChangedInfo.rowNode;
-                        adaptable.api.gridApi.refreshCell(rowNode, adaptableAlert.cellDataChangedInfo.column.columnId, true);
+                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightCell) {
+                        getAlertCellDataChangedInfos(adaptableAlert).forEach((cellChange) => {
+                            if (cellChange.rowNode && cellChange.column) {
+                                adaptable.api.gridApi.refreshCell(cellChange.rowNode, cellChange.column.columnId, true);
+                            }
+                        });
                     }
                     if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightRow &&
                         isAdaptableRowChangedAlert(adaptableAlert) &&
@@ -730,11 +731,12 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let ret = next(action);
                     let alerts = actionTyped.alerts;
                     alerts.forEach((alert) => {
-                        if (getRuleAlertProperties(alert.alertDefinition)?.HighlightCell &&
-                            isAdaptableCellChangedAlert(alert) &&
-                            alert.cellDataChangedInfo) {
-                            let rowNode = alert.cellDataChangedInfo.rowNode;
-                            adaptable.api.gridApi.refreshCell(rowNode, alert.cellDataChangedInfo.column.columnId, true);
+                        if (getRuleAlertProperties(alert.alertDefinition)?.HighlightCell) {
+                            getAlertCellDataChangedInfos(alert).forEach((cellChange) => {
+                                if (cellChange.rowNode && cellChange.column) {
+                                    adaptable.api.gridApi.refreshCell(cellChange.rowNode, cellChange.column.columnId, true);
+                                }
+                            });
                         }
                         if (getRuleAlertProperties(alert.alertDefinition)?.HighlightRow &&
                             isAdaptableRowChangedAlert(alert) &&
@@ -749,11 +751,11 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const actionTyped = action;
                     const adaptableAlert = actionTyped.alert;
                     if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightCell) {
-                        if (isAdaptableCellChangedAlert(adaptableAlert) &&
-                            adaptableAlert.cellDataChangedInfo) {
-                            const rowNode = adaptableAlert.cellDataChangedInfo.rowNode;
-                            adaptable.api.gridApi.refreshCell(rowNode, adaptableAlert.cellDataChangedInfo.column.columnId, true);
-                        }
+                        getAlertCellDataChangedInfos(adaptableAlert).forEach((cellChange) => {
+                            if (cellChange.rowNode && cellChange.column) {
+                                adaptable.api.gridApi.refreshCell(cellChange.rowNode, cellChange.column.columnId, true);
+                            }
+                        });
                     }
                     return ret;
                 }
@@ -762,9 +764,11 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const actionTyped = action;
                     const adaptableAlert = actionTyped.alert;
                     if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightRow) {
-                        if (isAdaptableCellChangedAlert(adaptableAlert) &&
-                            adaptableAlert.cellDataChangedInfo) {
-                            adaptable.api.gridApi.refreshRowNodes([adaptableAlert.cellDataChangedInfo.rowNode]);
+                        const highlightRowNodes = getAlertCellDataChangedInfos(adaptableAlert)
+                            .map((cellChange) => cellChange.rowNode)
+                            .filter((rowNode) => !!rowNode);
+                        if (highlightRowNodes.length) {
+                            adaptable.api.gridApi.refreshRowNodes(highlightRowNodes);
                         }
                         if (isAdaptableRowChangedAlert(adaptableAlert) && adaptableAlert.rowDataChangedInfo) {
                             adaptable.api.gridApi.refreshRowNodes(adaptableAlert.rowDataChangedInfo.rowNodes);

package/src/agGrid/AgGridColumnAdapter.js

@@ -928,6 +928,9 @@ export class AgGridColumnAdapter {
         return this.adaptableFloatingFilterComponent;
     }
     setupColumnFloatingFilter({ col, colDef }) {
+        if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
+            return;
+        }
         const userProvidedFilterProp = this.getUserColDefProperty(col.getColId(), 'filter');
         const hasInvalidFilterProp = typeof userProvidedFilterProp !== 'boolean' &&
             typeof userProvidedFilterProp?.handler !== 'function' &&
@@ -938,7 +941,6 @@ export class AgGridColumnAdapter {
         }
         const isFloatingFilterDisabled = !colDef.filter ||
             !colDef.floatingFilter ||
-            !this.adaptableOptions.filterOptions.useAdaptableFiltering ||
             !this.adaptableApi.filterApi.columnFilterApi.isQuickFilterVisible();
         if (this.adaptableApi.columnApi.isAutoRowGroupColumnForMulti(col.getColId())) {
             this.setColDefProperty(col, 'floatingFilter', (original_floatingFilter) => {