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

package/package.json

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

@@ -29,10 +29,6 @@ export interface UserInterfaceOptions<TData = any> {
      *
      */
     dateInputOptions?: DateInputOptions;
-    /**
-     * @deprecated Override `--ab-color-swatch-*`, `--ab-color-palette-*`, and semantic `--ab-color-*` variables in light/dark theme instead; will be removed in future release
-     */
-    colorPalette?: string[] | ((currentTheme: string) => string[]);
     /**
      * Style to set for editable Cells
      */
@@ -52,9 +48,11 @@ export interface UserInterfaceOptions<TData = any> {
      */
     styleClassNames?: string[];
     /**
-     * Optional list of AdaptableObjectTags that can be associated with AdaptableObjects
+     * Optional list of AdaptableObjectTags that can be associated with AdaptableObjects.
+     *
+     * When provided as a function, return `undefined` to provide no tags.
      */
-    objectTags?: AdaptableObjectTag[] | ((context: ObjectTagsContext) => AdaptableObjectTag[]);
+    objectTags?: AdaptableObjectTag[] | ((context: ObjectTagsContext) => AdaptableObjectTag[] | undefined);
     /**
      * Provide links to AdapTable documentation (in Module popups and Expression Editor)
      *

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

@@ -7,10 +7,14 @@ import { NumericStyledColumn } from './Common/NumericStyledColumn';
 export interface ZeroCentredColors {
     /**
      * Colour applied to negative cell values (`Col-Min`…`0`)
+     *
+     * @defaultValue `var(--ab-color-destructive)`
      */
     NegativeColor: string;
     /**
      * Colour applied to positive cell values (`0`…`Col-Max`)
+     *
+     * @defaultValue `var(--ab-color-success)`
      */
     PositiveColor: string;
 }

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/QuickSearchApiImpl.js

@@ -8,10 +8,10 @@ export class QuickSearchApiImpl extends ApiBase {
         return this.getAdaptableState().QuickSearch;
     }
     runQuickSearch(quickSearchText) {
-        this.dispatchAction(QuickSearchRedux.QuickSearchRun(quickSearchText));
+        this.dispatchAction(QuickSearchRedux.QuickSearchTextAction(quickSearchText));
     }
     clearQuickSearch() {
-        this.dispatchAction(QuickSearchRedux.QuickSearchRun(''));
+        this.dispatchAction(QuickSearchRedux.QuickSearchClear());
     }
     gotoNextMatch() {
         this.getAdaptableApi().agGridApi.findNext();

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/Implementation/UserInterfaceApiImpl.d.ts

@@ -11,7 +11,6 @@ export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfa
     internalApi: UserInterfaceInternalApi;
     private showProgressIndicatorTimeout;
     constructor(_adaptable: IAdaptable);
-    getColorPalette(): string[];
     getCustomIcons(): CustomIcon[];
     getStyleClassNames(): string[] | undefined;
     getEditableCellStyle(): AdaptableStyle | undefined;

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -1,8 +1,6 @@
 import * as PopupRedux from '../../Redux/ActionsReducers/PopupRedux';
 import { ArrayExtensions } from '../../Utilities/Extensions/ArrayExtensions';
 import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
-import { logDeprecation } from '../../Utilities/logDeprecation';
-import UIHelper from '../../Utilities/Helpers/UIHelper';
 import { CUSTOM_WINDOW_FACTORY_ID } from '../../View/Components/Popups/WindowPopups/WindowPopups';
 import { UserInterfaceInternalApi } from '../Internal/UserInterfaceInternalApi';
 import { ApiBase } from './ApiBase';
@@ -15,16 +13,6 @@ export class UserInterfaceApiImpl extends ApiBase {
         super(_adaptable);
         this.internalApi = new UserInterfaceInternalApi(_adaptable);
     }
-    getColorPalette() {
-        const colorPalette = this.getUserInterfaceOptions().colorPalette;
-        if (colorPalette != null) {
-            logDeprecation(this._adaptable.logger, 'UserInterfaceOptions', 'colorPalette', undefined, 'Override `--ab-color-swatch-*`, `--ab-color-palette-*`, and semantic `--ab-color-*` variables in your light or dark theme CSS instead. `colorPalette` will be removed in a future major release.');
-            if (typeof colorPalette === 'function' || Array.isArray(colorPalette)) {
-                return resolveValueOrFunction(colorPalette, this.getThemeApi().getCurrentTheme());
-            }
-        }
-        return UIHelper.getDefaultColorPalette();
-    }
     getCustomIcons() {
         return resolveValueOrFunction(this.getUserInterfaceOptions().customIcons) ?? [];
     }
@@ -42,9 +30,15 @@ export class UserInterfaceApiImpl extends ApiBase {
     }
     getAdaptableObjectTags() {
         const objectTags = this.getUserInterfaceOptions().objectTags;
-        const resolvedTags = resolveValueOrFunction(objectTags, this.getAdaptableInternalApi().buildBaseContext());
-        if (resolvedTags && ArrayExtensions.IsNotNullOrEmpty(resolvedTags)) {
-            return resolvedTags;
+        if (typeof objectTags === 'function') {
+            const tags = objectTags(this.getAdaptableInternalApi().buildBaseContext());
+            if (!Array.isArray(tags)) {
+                return;
+            }
+            return tags.filter((tag) => typeof tag === 'string');
+        }
+        if (objectTags && ArrayExtensions.IsNotNullOrEmpty(objectTags)) {
+            return objectTags;
         }
     }
     getAdaptableObjectsWithTag(tag, adaptableModule) {

package/src/Api/Internal/AdaptableInternalApi.js

@@ -276,9 +276,11 @@ export class AdaptableInternalApi extends ApiBase {
             return userInterfaceOptions.objectTags;
         }
         if (typeof userInterfaceOptions.objectTags === 'function') {
-            return userInterfaceOptions
-                .objectTags(this.buildBaseContext())
-                .filter((tag) => typeof tag === 'string');
+            const tags = userInterfaceOptions.objectTags(this.buildBaseContext());
+            if (!Array.isArray(tags)) {
+                return;
+            }
+            return tags.filter((tag) => typeof tag === 'string');
         }
     }
     dispatchReduxAction(action) {

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'),
@@ -92,14 +92,15 @@ export class StateInternalApi extends ApiBase {
                         rowModelType: this._adaptable.agGridAdapter.getGridOption('rowModelType'),
                         treeData: this._adaptable.agGridAdapter.getGridOption('treeData'),
                     };
-                    const clonedState = state.Internal
-                        ? JSON.parse(JSON.stringify(state))
-                        : getPersistableState(JSON.parse(JSON.stringify(state)));
+                    const clonedState = getPersistableState(JSON.parse(JSON.stringify(state)));
                     let processedState = this._adaptable.migrateLoadedAdaptableState(clonedState);
                     processedState = this._adaptable.normalizeAdaptableState(processedState, agGridOptions);
+                    const oldState = this.getAdaptableApi().stateApi.getPersistentState();
                     this.getAdaptableStore().TheStore.dispatch(LoadState(processedState));
                     this.getAdaptableStore().TheStore.dispatch(InitState());
                     this._adaptable.refreshLayout();
+                    const newState = this.getAdaptableApi().stateApi.getPersistentState();
+                    this.getEventApi().internalApi.fireAdaptableStateReloadedEvent(oldState, newState);
                     void this.getAdaptableStore()
                         .saveStateNow(this._adaptable)
                         .then(() => resolve())

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/Api/UserInterfaceApi.d.ts

@@ -8,10 +8,6 @@ import { UserInterfaceState } from '../AdaptableState/UserInterfaceState';
  * Functions relating to User Interface section of Adaptable State
  */
 export interface UserInterfaceApi {
-    /**
-     * Retrieves Color Palette currently being used
-     */
-    getColorPalette(): string[];
     /**
      * Retrieves Custom Icons provided by users
      */

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;
@@ -18,6 +14,10 @@ export declare const QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE: {
  * @ReduxAction Runs Quick Search
  */
 export declare const QUICK_SEARCH_RUN = "QUICK_SEARCH_RUN";
+/**
+ * @ReduxAction Clears Quick Search text
+ */
+export declare const QUICK_SEARCH_CLEAR = "QUICK_SEARCH_CLEAR";
 /**
  * @ReduxAction Sets Quick Search whole-cell style (SSRM / legacy)
  */
@@ -37,6 +37,8 @@ export declare const QUICK_SEARCH_READY = "QUICK_SEARCH_READY";
 export interface QuickSearchRunAction extends Redux.Action {
     quickSearchText: string;
 }
+export interface QuickSearchClearAction extends Redux.Action {
+}
 export interface QuickSearchSetMatchingCellStyleAction extends Redux.Action {
     matchingCellStyle: AdaptableStyle;
 }
@@ -50,6 +52,9 @@ export interface QuickSearchReadyAction extends Redux.Action {
     quickSearchState: QuickSearchState;
 }
 export declare const QuickSearchRun: (quickSearchText: string) => QuickSearchRunAction;
+export declare const QuickSearchClear: () => QuickSearchClearAction;
+/** Runs Quick Search, or clears it when the text is empty. */
+export declare const QuickSearchTextAction: (quickSearchText: string) => QuickSearchRunAction | QuickSearchClearAction;
 export declare const QuickSearchSetCellMatchingStyle: (matchingCellStyle: AdaptableStyle) => QuickSearchSetMatchingCellStyleAction;
 export declare const QuickSearchSetTextMatchingStyle: (textMatchStyle: AdaptableStyle) => QuickSearchSetTextMatchingStyleAction;
 export declare const QuickSearchSetCurrentTextMatchingStyle: (currentTextMatchStyle: AdaptableStyle) => QuickSearchSetCurrentTextMatchingStyleAction;

package/src/Redux/ActionsReducers/QuickSearchRedux.js

@@ -1,19 +1,16 @@
-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';
+export const QUICK_SEARCH_CLEAR = 'QUICK_SEARCH_CLEAR';
 export const QUICK_SEARCH_SET_CELL_MATCHING_STYLE = 'QUICK_SEARCH_SET_CELL_MATCHING_STYLE';
 export const QUICK_SEARCH_SET_TEXT_MATCHING_STYLE = 'QUICK_SEARCH_SET_TEXT_MATCHING_STYLE';
 export const QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE = 'QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE';
@@ -22,6 +19,10 @@ export const QuickSearchRun = (quickSearchText) => ({
     type: QUICK_SEARCH_RUN,
     quickSearchText,
 });
+export const QuickSearchClear = () => ({
+    type: QUICK_SEARCH_CLEAR,
+});
+export const QuickSearchTextAction = (quickSearchText) => quickSearchText ? QuickSearchRun(quickSearchText) : QuickSearchClear();
 export const QuickSearchSetCellMatchingStyle = (matchingCellStyle) => ({
     type: QUICK_SEARCH_SET_CELL_MATCHING_STYLE,
     matchingCellStyle: matchingCellStyle,
@@ -47,6 +48,10 @@ export const QuickSearchReducer = (state = initialState, action) => {
             return Object.assign({}, state, {
                 QuickSearchText: action.quickSearchText,
             });
+        case QUICK_SEARCH_CLEAR:
+            return Object.assign({}, state, {
+                QuickSearchText: EMPTY_STRING,
+            });
         case QUICK_SEARCH_SET_CELL_MATCHING_STYLE:
             return Object.assign({}, state, {
                 CellMatchStyle: action.matchingCellStyle,