@adaptabletools/adaptable 24.0.0-canary.4 → 24.0.0-canary.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "24.0.0-canary.4",
+  "version": "24.0.0-canary.6",
   "description": "Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -59,6 +59,7 @@
     "normalize.css": "^8.0.1",
     "re-resizable": "6.10.3",
     "react": "^18.0.0 || ^19.0.0",
+    "react-colorful": "^5.8.1",
     "react-day-picker": "^9.14.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "react-redux": "9.2.0",

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -9,7 +9,7 @@ import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
 import { AdaptableTheme } from '../AdaptableState/ThemeState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
 import { IModuleCollection } from '../Strategy/Interface/IModule';
-import { AdaptableMenuItem, AdaptableOptions, AdaptablePlugin, AdaptableState, ChartDefinition, InFilterValueResult, SelectedRowInfo } from '../types';
+import { AdaptableMenuItem, AdaptableOptions, AdaptablePersistentState, AdaptablePlugin, ChartDefinition, InFilterValueResult, SelectedRowInfo } from '../types';
 import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
 import { CommentsService } from '../Utilities/Services/CommentsService';
@@ -326,17 +326,17 @@ export interface IAdaptable {
     canExportToExcel(): boolean;
     canExportToCsv(): boolean;
     silentUpdateCurrentLayoutModel(layoutModel?: TableLayoutModel | PivotLayoutModel): void;
-    normalizeAdaptableState(state: AdaptableState, options: NormalizeAdaptableStateOptions): AdaptableState;
+    normalizeAdaptableState(state: Partial<AdaptablePersistentState>, options: NormalizeAdaptableStateOptions): Partial<AdaptablePersistentState>;
     /**
      * Runs the startup upgrade chain when `stateOptions.autoMigrateState` is on.
      * A no-op when migration is disabled or the state is already current.
      */
-    migrateLoadedAdaptableState(state: AdaptableState): AdaptableState;
+    migrateLoadedAdaptableState<T extends Partial<AdaptablePersistentState>>(state: T): T;
     /**
      * `loadStore` hook used at startup and when the state key changes:
      * migrate (when enabled), then normalise.
      */
-    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: AdaptableState) => AdaptableState;
+    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: Partial<AdaptablePersistentState>) => Partial<AdaptablePersistentState>;
     refreshLayout(): void;
 }
 export type NormalizeAdaptableStateOptions = Pick<GridOptions, 'rowModelType' | 'treeData' | 'columnDefs' | 'autoGroupColumnDef' | 'defaultColDef' | 'pivotMode'>;

package/src/AdaptableOptions/DefaultAdaptableOptions.js

@@ -1,5 +1,5 @@
 import * as GeneralConstants from '../Utilities/Constants/GeneralConstants';
-import { getGraySwatchColor, getSwatchColorVar } from '../Utilities/Helpers/UIHelper';
+import { themeColorVar } from '../Utilities/Helpers/UIHelper';
 import { ACCESS_LEVEL_FULL, EMPTY_STRING, EMPTY_ARRAY, DEFAULT_DATE_FORMAT_PATTERN_WITH_TIME, SYSTEM_REPORT_NAMES, SYSTEM_REPORT_FORMATS, SYSTEM_EXPORT_DESTINATIONS, } from '../Utilities/Constants/GeneralConstants';
 import { addUuidsToInitialState } from '../Utilities/Helpers/AdaptableHelper';
 import { defaultsDeep } from '../Utilities/Extensions/ObjectExtensions';
@@ -200,13 +200,13 @@ const DefaultAdaptableOptions = {
         defaultFlashDuration: 500,
         defaultFlashTarget: 'cell',
         defaultDownChangeStyle: {
-            BackColor: getSwatchColorVar(18),
+            BackColor: themeColorVar('flash-down'),
         },
         defaultUpChangeStyle: {
-            BackColor: getSwatchColorVar(7),
+            BackColor: themeColorVar('flash-up'),
         },
         defaultNeutralChangeStyle: {
-            BackColor: getGraySwatchColor(),
+            BackColor: themeColorVar('flash-neutral'),
         },
     },
     formatColumnOptions: {
@@ -279,7 +279,7 @@ const DefaultAdaptableOptions = {
         position: undefined,
         size: undefined,
         customSettingsPanels: undefined,
-        gridInfoTabs: ['Grid Options', 'Grid Summary', 'Grid State'],
+        gridInfoTabs: ['Grid Summary', 'Layout', 'Grid State', 'Grid Options'],
     },
     wizardOptions: {
         popupType: undefined,

package/src/AdaptableOptions/FlashingCellOptions.d.ts

@@ -10,17 +10,17 @@ export interface FlashingCellOptions {
     defaultFlashTarget?: FlashTarget;
     /**
      * Style for 'Down' value changes
-     *  @defaultValue  Red BackColour
+     * @defaultValue  BackColor of `var(--ab-color-flash-down)` (red in the shipped themes)
      */
     defaultDownChangeStyle?: AdaptableStyle;
     /**
      * Style for 'Up' value changes
-     * @defaultValue  Green BackColour
+     * @defaultValue  BackColor of `var(--ab-color-flash-up)` (green in the shipped themes)
      */
     defaultUpChangeStyle?: AdaptableStyle;
     /**
      * Style for 'Neutral' value changes
-     * @defaultValue  Gray BackColour
+     * @defaultValue  BackColor of `var(--ab-color-flash-neutral)` (gray in the shipped themes)
      */
     defaultNeutralChangeStyle?: AdaptableStyle;
     /**

package/src/AdaptableOptions/SettingsPanelOptions.d.ts

@@ -74,9 +74,11 @@ export interface SettingsPanelOptions {
      */
     customSettingsPanels?: CustomSettingsPanel[];
     /**
-     * Which Tabs can be used to display Grid Info: 'Grid Options', 'Grid Summary' or 'Grid State'
+     * Which Tabs to show in Grid Info: 'Grid Summary', 'Layout', 'Grid State' or 'Grid Options'
      *
-     * @defaultValue ['Grid Options', 'Grid Summary', 'Grid State']
+     * Tab labels in the UI are Summary, Layout, State and Options
+     *
+     * @defaultValue ['Grid Summary', 'Layout', 'Grid State', 'Grid Options']
      */
     gridInfoTabs?: GridInfoTabs;
 }
@@ -182,6 +184,6 @@ export type PopupType = 'modal' | 'window';
  */
 export type GridInfoTabs = GridInfoTab[];
 /**
- * Tab to use for Grid Info: 'Grid Options', 'Grid Summary' or 'Grid State'
+ * Tab to use for Grid Info: 'Grid Summary', 'Layout', 'Grid State' or 'Grid Options'
  */
-export type GridInfoTab = 'Grid Options' | 'Grid Summary' | 'Grid State';
+export type GridInfoTab = 'Grid Summary' | 'Layout' | 'Grid State' | 'Grid Options';

package/src/AdaptableOptions/StateOptions.d.ts

@@ -1,12 +1,22 @@
-import { AdaptableState } from '../AdaptableState/AdaptableState';
+import { AdaptablePersistentState } from '../AdaptableState/AdaptableState';
 import { AdaptableApi } from '../Api/AdaptableApi';
 /**
  * Options related to Adaptable State hydration / dehydration; allows users to intercept state persistence and loading with custom functionality
+ *
+ * All functions deal with `AdaptablePersistentState` - the persisted subset of `AdaptableState`.
+ * Transient sections (`Internal`, `Popup`, `Comment`, `Plugins`) are never passed to, nor expected from, these functions.
+ *
+ * Hydration flow: `loadState()` -> (merge with `initialState`) -> `applyState()`
+ *
+ * Dehydration flow: `saveState()` -> `persistState()`
+ *
+ * To store Adaptable State in a custom format (e.g. wrapped in an envelope, compressed, encrypted) do the wrapping in `persistState()` and the unwrapping in `loadState()` - these are the only functions which own the storage format.
+ * `saveState()` and `applyState()` always operate on Adaptable State, as `loadState()`'s result is merged with `initialState` section by section before `applyState()` is called.
  */
 export interface StateOptions {
     /**
      * Retrieves saved Adaptable State from storage or external source
-     * @returns Promise resolving to the retrieved state object
+     * @returns Promise resolving to the retrieved (possibly partial) state object, or to nothing if no state was persisted yet
      */
     loadState?: AdaptableLoadStateFunction;
     /**
@@ -15,7 +25,7 @@ export interface StateOptions {
      */
     persistState?: AdaptablePersistStateFunction;
     /**
-     * Transforms state before applying it to the application. Called after `loadState()` but before the state is used.
+     * Transforms state before applying it to the application. Called after `loadState()` (and after merging with `initialState`) but before the state is used.
      * @returns The transformed state object
      */
     applyState?: AdaptableApplyStateFunction;
@@ -74,63 +84,77 @@ export interface AdaptableStateFunctionConfig {
      */
     actionName?: string;
     /**
-     * Previous state before the action was applied.
+     * Previous (persistent) state before the action was applied.
      * This is useful for comparing changes or reverting if necessary.
      */
-    previousState?: AdaptableState;
+    previousState?: AdaptablePersistentState;
 }
 /**
  * Function that handles persisting state to storage systems (localStorage, server, etc.).
  * Called after `saveState()` to store the prepared state.
  *
+ * This is the place to apply any custom storage format (envelope, compression, encryption, etc.); the matching `loadState()` is expected to undo it.
+ *
  * @example
  * ```
  * persistState = (state, stateFunctionConfig) => {
- *  localStorage.setItem(stateFunctionConfig.adaptableStateKey, JSON.stringify(state))
+ *  localStorage.setItem(stateFunctionConfig.adaptableStateKey, JSON.stringify(state));
+ *  return Promise.resolve();
  * }
  * ```
  *
  * @param state The state to be persisted
  * @param adaptableStateFunctionConfig Configuration details for the current Adaptable instance
- * @returns Promise resolving once persistence is complete
+ * @returns Promise resolving once persistence is complete; the resolved value is ignored
  */
 export interface AdaptablePersistStateFunction {
-    (state: any, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): Promise<any>;
+    (state: AdaptablePersistentState, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): Promise<unknown>;
 }
 /**
  * Function that clears persisted state from the storage system.
  * Only invoked during `StateApi.reloadInitialState()` operations.
+ *
+ * @returns Promise resolving once the persisted state is cleared; the resolved value is ignored
  */
 export interface AdaptableClearStateFunction {
-    (adaptableStateFunctionConfig: AdaptableStateFunctionConfig): Promise<any>;
+    (adaptableStateFunctionConfig: AdaptableStateFunctionConfig): Promise<unknown>;
 }
 /**
  * Function that transforms state before persistence. Called first in the persistence flow, before `persistState()`.
  *
+ * The received state is the full persistent state of the current Adaptable instance (transient sections are already stripped).
+ *
  * @param state The Adaptable state to transform before saving
  * @param adaptableStateFunctionConfig Configuration details for the current Adaptable instance
  * @returns The modified state ready for persistence
  */
 export interface AdaptableSaveStateFunction {
-    (state: AdaptableState, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): any;
+    (state: AdaptablePersistentState, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): AdaptablePersistentState;
 }
 /**
  * Function that retrieves Adaptable state from storage or external source. Called during initialization to hydrate the application state.
  *
+ * The result is merged with `AdaptableOptions.initialState` before being passed to `applyState()`, so it may be partial (only the sections which were persisted) or empty / nullish (nothing was persisted yet).
+ *
+ * This is the place to undo any custom storage format applied in `persistState()`.
+ *
  * @param config Configuration details for the current Adaptable instance
  * @returns Promise resolving to the retrieved state object
  */
 export interface AdaptableLoadStateFunction {
-    (config: AdaptableStateFunctionConfig): Promise<any>;
+    (config: AdaptableStateFunctionConfig): Promise<Partial<AdaptablePersistentState> | null | void>;
 }
 /**
- * Function that applies the loaded state to the application. Called after `loadState()` but before the state is used.
+ * Function that applies the loaded state to the application. Called after `loadState()` (and after the result was merged with `initialState`) but before the state is used.
  * This allows for any necessary transformations or adjustments before the state is applied.
+ *
+ * The state is partial, as only the sections present in either the persisted state or `initialState` are available at this point; missing sections are initialised with their defaults afterwards.
+ *
  * @param state The loaded state to transform
  * @param adaptableStateFunctionConfig Configuration details for the current Adaptable instance
  *
  * @returns The transformed state object
  */
 export interface AdaptableApplyStateFunction {
-    (state: any, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): any;
+    (state: Partial<AdaptablePersistentState>, adaptableStateFunctionConfig: AdaptableStateFunctionConfig): Partial<AdaptablePersistentState>;
 }

package/src/AdaptableState/AdaptableState.d.ts

@@ -32,6 +32,8 @@ export interface AdaptableState extends AdaptablePersistentState, AdaptableTrans
 }
 /**
  * The state object of Adaptable which is persisted
+ *
+ * This is the state shape handled by all `StateOptions` functions (`saveState`, `persistState`, `loadState`, `applyState`)
  */
 export interface AdaptablePersistentState {
     Application: ApplicationState;

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/AdaptableState/QuickSearchState.d.ts

@@ -14,10 +14,14 @@ export interface QuickSearchState extends BaseState {
     CellMatchStyle?: Omit<AdaptableStyle, 'ClassName'>;
     /**
      * Style used to highlight matching text within a cell (not availale in SSRM)
+     *
+     * @defaultValue `var(--ab-color-quick-search-match)` background and `var(--ab-color-quick-search-match-foreground)` text
      */
     TextMatchStyle?: Omit<AdaptableStyle, 'ClassName'>;
     /**
      * Style used to highlight matching text within current match (not availale in SSRM)
+     *
+     * @defaultValue `var(--ab-color-quick-search-current-match)` background, `var(--ab-color-quick-search-current-match-foreground)` text, bold
      */
     CurrentTextMatchStyle?: Omit<AdaptableStyle, 'ClassName'>;
 }

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/Implementation/ColumnScopeApiImpl.js

@@ -1,6 +1,6 @@
 import { ApiBase } from './ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
-import { getGraySwatchColor } from '../../Utilities/Helpers/UIHelper';
+import { getDefaultRangeColor } from '../../Utilities/Helpers/UIHelper';
 export class ColumnScopeApiImpl extends ApiBase {
     isColumnInScope(column, scope) {
         if (!column) {
@@ -238,7 +238,7 @@ export class ColumnScopeApiImpl extends ApiBase {
                 {
                     Min: 0,
                     Max: 0,
-                    Color: getGraySwatchColor(),
+                    Color: getDefaultRangeColor(),
                 },
             ];
         }
@@ -246,7 +246,7 @@ export class ColumnScopeApiImpl extends ApiBase {
             {
                 Min: 'Col-Min',
                 Max: 'Col-Max',
-                Color: getGraySwatchColor(),
+                Color: getDefaultRangeColor(),
             },
         ];
     }

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

@@ -43,7 +43,7 @@ export declare class StateApiImpl extends ApiBase implements StateApi {
         flushCurrentState?: boolean;
         progressIndicatorLabel?: string;
     }): Promise<void>;
-    persistAdaptableState(): Promise<AdaptableState>;
+    persistAdaptableState(): Promise<AdaptablePersistentState>;
     getDescriptionForModule(module: AdaptableModule): string;
     getHelpPageForModule(module: AdaptableModule): string;
     getUserStateByStateKey(stateKey: AdaptableStateKey, returnJson?: boolean): BaseState | string;

package/src/Api/Implementation/StateApiImpl.js

@@ -1,4 +1,6 @@
 import { InitState } from '../../Redux/Store/AdaptableStore';
+import { runAsyncStateFunction } from '../../Redux/Store/StateOptionsGuards';
+import { loadState as defaultLoadState } from '../../Redux/Store/AdaptableReduxLocalStorageEngine';
 import { ApiBase } from './ApiBase';
 import Helper from '../../Utilities/Helpers/Helper';
 import { addUuidsToInitialState } from '../../Utilities/Helpers/AdaptableHelper';
@@ -56,7 +58,7 @@ export class StateApiImpl extends ApiBase {
                 localStorage.removeItem(adaptableOptions.adaptableStateKey);
                 return Promise.resolve(true);
             });
-        const clearStatePromise = clearStateFn(this.internalApi.buildAdaptableStateFunctionConfig());
+        const clearStatePromise = runAsyncStateFunction('clearState', clearStateFn, [this.internalApi.buildAdaptableStateFunctionConfig()], this._adaptable.logger);
         return clearStatePromise.then(() => {
             this.setAdaptableStateKey(adaptableOptions.adaptableStateKey, {
                 initialState: newInitialState || adaptableOptions.initialState,
@@ -82,8 +84,7 @@ export class StateApiImpl extends ApiBase {
     }
     async remergePersistedState() {
         const config = this.internalApi.buildAdaptableStateFunctionConfig();
-        const loadState = this.getOptions().stateOptions.loadState;
-        const userState = await loadState(config);
+        const userState = await runAsyncStateFunction('loadState', this.getOptions().stateOptions.loadState || defaultLoadState, [config], this._adaptable.logger);
         return this.internalApi.applyMergedInitialAndUserState(this.getInitialState(), userState);
     }
     getAllState() {

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/Api/Internal/CalculatedColumnInternalApi.js

@@ -221,7 +221,7 @@ export class CalculatedColumnInternalApi extends ApiBase {
             if (calculatedColumnSettings.ShowToolTip != null &&
                 calculatedColumnSettings.ShowToolTip == true) {
                 newColDef.tooltipComponent = TwoLineTooltip;
-                newColDef.tooltipValueGetter = (params) => {
+                newColDef.tooltip = (params) => {
                     const formulaText = this.getAdaptableInternalApi().getAdaptableQueryExpressionText(calculatedColumn.Expression);
                     if (!isPerRowCalculatedColumnType(getCalculatedColumnType(calculatedColumn)) ||
                         !params?.node ||

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

@@ -7,7 +7,7 @@ export declare class StateInternalApi extends ApiBase {
      * Startup-equivalent merge: Initial State + user state → store, layout/theme/cells, persist.
      * Does not clear persistence and does not call `loadState` (caller supplies user state).
      */
-    applyMergedInitialAndUserState(initialState: InitialState, userState: AdaptablePersistentState | Record<string, unknown> | null | undefined): Promise<void>;
+    applyMergedInitialAndUserState(initialState: InitialState, userState: Partial<AdaptablePersistentState> | null | void): Promise<void>;
     getAllStateForDevTools(): AdaptableState;
     /**
      * Replaces persisted Adaptable state with the supplied snapshot (e.g. from DevTools).

package/src/Api/Internal/StateInternalApi.js

@@ -1,5 +1,6 @@
 import { getPersistableState, LoadState, InitState } from '../../Redux/Store/AdaptableStore';
 import { MergeStateFunction } from '../../Redux/Store/AdaptableReduxMerger';
+import { runSyncStateFunction } from '../../Redux/Store/StateOptionsGuards';
 import { addUuidsToInitialState } from '../../Utilities/Helpers/AdaptableHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 function deepClone(value) {
@@ -23,8 +24,7 @@ export class StateInternalApi extends ApiBase {
                     const initialForMerge = addUuidsToInitialState(deepClone(initialState));
                     const userForMerge = deepClone(userState ?? {});
                     let merged = MergeStateFunction(initialForMerge, userForMerge);
-                    const stateFunctionConfig = this.buildAdaptableStateFunctionConfig();
-                    merged = this.getOptions().stateOptions.applyState(merged, stateFunctionConfig);
+                    merged = runSyncStateFunction('applyState', this.getOptions().stateOptions.applyState, merged, this.buildAdaptableStateFunctionConfig(), this._adaptable.logger);
                     merged = this._adaptable.migrateLoadedAdaptableState(merged);
                     const agGridOptions = {
                         columnDefs: this._adaptable.agGridAdapter.getGridOption('columnDefs'),

package/src/Api/StateApi.d.ts

@@ -224,7 +224,7 @@ export interface StateApi {
      * This method first calls StateOption.saveState() to prepare the state
      * and then StateOptions.persistState() to save it to the configured storage.
      *
-     * @returns Promise<AdaptableState> - A promise that resolves to the persisted state
+     * @returns A promise that resolves to the persisted state
      */
-    persistAdaptableState(): Promise<AdaptableState>;
+    persistAdaptableState(): Promise<AdaptablePersistentState>;
 }

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/ActionsReducers/QuickSearchRedux.d.ts

@@ -1,10 +1,6 @@
 import * as Redux from 'redux';
 import { QuickSearchState } from '../../AdaptableState/QuickSearchState';
 import { AdaptableStyle } from '../../AdaptableState/Common/AdaptableStyle';
-export declare const QUICK_SEARCH_DEFAULT_CELL_MATCH_STYLE: {
-    BackColor: string;
-    ForeColor: string;
-};
 export declare const QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE: {
     BackColor: string;
     ForeColor: string;