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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "24.0.0-canary.5",
+  "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/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/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/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/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;

package/src/Redux/ActionsReducers/QuickSearchRedux.js

@@ -1,16 +1,12 @@
-import { QUICK_SEARCH_DEFAULT_CELL_BACK_COLOR, QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR, QUICK_SEARCH_DEFAULT_FORE_COLOR, QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR, } from '../../Utilities/Constants/ReduxConstants';
+import { QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR, QUICK_SEARCH_DEFAULT_CURRENT_FORE_COLOR, QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR, QUICK_SEARCH_DEFAULT_TEXT_FORE_COLOR, } from '../../Utilities/Constants/ReduxConstants';
 import { EMPTY_STRING } from '../../Utilities/Constants/GeneralConstants';
-export const QUICK_SEARCH_DEFAULT_CELL_MATCH_STYLE = {
-    BackColor: QUICK_SEARCH_DEFAULT_CELL_BACK_COLOR,
-    ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
-};
 export const QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE = {
     BackColor: QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR,
-    ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
+    ForeColor: QUICK_SEARCH_DEFAULT_TEXT_FORE_COLOR,
 };
 export const QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE = {
     BackColor: QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR,
-    ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
+    ForeColor: QUICK_SEARCH_DEFAULT_CURRENT_FORE_COLOR,
     FontWeight: 'Bold',
 };
 export const QUICK_SEARCH_RUN = 'QUICK_SEARCH_RUN';

package/src/Redux/Store/AdaptableReduxLocalStorageEngine.d.ts

@@ -1,6 +1,14 @@
 import IStorageEngine from './Interface/IStorageEngine';
 import { InitialState } from '../../AdaptableState/InitialState';
 import { AdaptableLoadStateFunction, AdaptablePersistStateFunction } from '../../AdaptableOptions/StateOptions';
+/**
+ * Default `persistState` implementation - writes the state to localStorage under `adaptableStateKey`
+ */
+export declare const persistState: AdaptablePersistStateFunction;
+/**
+ * Default `loadState` implementation - reads the state from localStorage under `adaptableStateKey`
+ */
+export declare const loadState: AdaptableLoadStateFunction;
 export declare function createEngine(config: {
     adaptableId: string;
     adaptableStateKey: string;

package/src/Redux/Store/AdaptableReduxLocalStorageEngine.js

@@ -1,6 +1,7 @@
 import { debounce } from '../../Utilities/Helpers/TimingHelper';
 import { MergeStateFunction } from './AdaptableReduxMerger';
 import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
+import { runAsyncStateFunction, runSyncStateFunction } from './StateOptionsGuards';
 const checkStatus = (response) => {
     const error = new Error(response.statusText);
     if (response.status >= 200 && response.status < 300) {
@@ -8,7 +9,7 @@ const checkStatus = (response) => {
     }
     throw error;
 };
-const persistState = (state, config) => {
+export const persistState = (state, config) => {
     return new Promise((resolve, reject) => {
         try {
             localStorage.setItem(config.adaptableStateKey, JSON.stringify(state));
@@ -19,7 +20,7 @@ const persistState = (state, config) => {
         }
     });
 };
-const loadState = ({ adaptableId, adaptableStateKey }) => {
+export const loadState = ({ adaptableStateKey }) => {
     const jsonState = localStorage.getItem(adaptableStateKey);
     const parsedJsonState = JSON.parse(jsonState) || {};
     return Promise.resolve(parsedJsonState);
@@ -49,7 +50,7 @@ class AdaptableReduxLocalStorageEngine {
         this.adaptableStateKey = adaptableStateKey;
     }
     load(adaptableInstance, initialState = this.initialState) {
-        return (this.loadState || loadState)(adaptableInstance.api.stateApi.internalApi.buildAdaptableStateFunctionConfig()).then((parsedJsonState) => {
+        return runAsyncStateFunction('loadState', this.loadState || loadState, [adaptableInstance.api.stateApi.internalApi.buildAdaptableStateFunctionConfig()], adaptableInstance.logger).then((parsedJsonState) => {
             return Promise.resolve(initialState)
                 .then((parsedInitialState) => {
                 return MergeStateFunction(parsedInitialState, parsedJsonState);
@@ -67,20 +68,19 @@ class AdaptableReduxLocalStorageEngine {
         const config = adaptableInstance.api.stateApi.internalApi.buildAdaptableStateFunctionConfig();
         config.actionName = actionName;
         config.previousState = adaptableInstance.adaptableStore.getPreviousStorageState() || null;
-        let stateObject = structuredClone(state);
-        const getTransformedState = adaptableInstance.adaptableOptions.stateOptions.saveState;
-        if (getTransformedState) {
-            stateObject = getTransformedState(stateObject, config);
+        let stateObject;
+        try {
+            stateObject = runSyncStateFunction('saveState', adaptableInstance.adaptableOptions.stateOptions.saveState, structuredClone(state), config, adaptableInstance.logger);
         }
-        const promise = (this.persistState || persistState)(stateObject, config)?.catch(rejectWithMessage);
-        if (!(promise instanceof Promise)) {
-            AdaptableLogger.consoleWarnBase(`AdaptableId: ${this.adaptableId}`, 'stateOptions.persistState should return a promise, it returned', 'Error', promise);
+        catch (error) {
+            adaptableInstance.logger.consoleError('Adaptable State was NOT persisted:', error instanceof Error ? error.message : error);
+            return Promise.reject(error);
         }
-        return promise;
+        return runAsyncStateFunction('persistState', this.persistState || persistState, [stateObject, config], adaptableInstance.logger).catch(rejectWithMessage);
     }
 }
 function rejectWithMessage(error) {
-    return Promise.reject(error.message);
+    return Promise.reject(error?.message ?? error);
 }
 export function createEngine(config) {
     return new AdaptableReduxLocalStorageEngine(config);

package/src/Redux/Store/AdaptableStore.d.ts

@@ -1,11 +1,14 @@
 import * as Redux from 'redux';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableState } from '../../AdaptableState/AdaptableState';
+import { AdaptablePersistentState, AdaptableState } from '../../AdaptableState/AdaptableState';
 import { BaseState } from '../../AdaptableState/BaseState';
 import { IAdaptableStore, LoadStoreConfig } from './Interface/IAdaptableStore';
 type EmitterCallback = (data?: any) => any;
 type EmitterAnyCallback = (eventName: string, data?: any) => any;
-export declare const getPersistableState: (state: AdaptableState) => AdaptableState;
+/**
+ * Strips the transient (non-persisted) sections from the given state object - mutates and returns the same object.
+ */
+export declare const getPersistableState: (state: AdaptableState) => AdaptablePersistentState;
 export interface ResetUserDataAction extends Redux.Action {
 }
 export interface InitStateAction extends Redux.Action {
@@ -40,9 +43,9 @@ export declare class AdaptableStore implements IAdaptableStore {
      */
     constructor(adaptable: IAdaptable);
     destroy(): void;
-    getCurrentStorageState(): AdaptableState;
-    getPreviousStorageState(): AdaptableState;
-    saveStateNow(adaptable: IAdaptable, state?: AdaptableState): Promise<any>;
+    getCurrentStorageState(): AdaptablePersistentState;
+    getPreviousStorageState(): AdaptablePersistentState;
+    saveStateNow(adaptable: IAdaptable, state?: AdaptablePersistentState): Promise<any>;
     loadStore: (config: LoadStoreConfig) => Promise<any>;
 }
 export {};