@adaptabletools/adaptable 22.0.0-canary.1 → 22.0.0-canary.10

package/src/migration/AdaptableUpgradeHelper.js

@@ -3,7 +3,11 @@ import { VersionUpgrade18 } from './VersionUpgrade18';
 import { ADAPTABLE_VERSION } from '../EnvVars';
 import { VersionUpgrade20 } from './VersionUpgrade20';
 import { VersionUpgrade21 } from './VersionUpgrade21';
+import { VersionUpgrade22 } from './VersionUpgrade22';
 export class AdaptableUpgradeHelper {
+    currentMajorVersion;
+    versionUpgrades;
+    logger;
     constructor(logger) {
         this.currentMajorVersion = this.getCurrentMajorVersion(ADAPTABLE_VERSION);
         this.logger = logger || this.getConsoleLogger();
@@ -12,6 +16,7 @@ export class AdaptableUpgradeHelper {
         this.versionUpgrades.set(18, new VersionUpgrade18(this.logger));
         this.versionUpgrades.set(20, new VersionUpgrade20(this.logger));
         this.versionUpgrades.set(21, new VersionUpgrade21(this.logger));
+        this.versionUpgrades.set(22, new VersionUpgrade22(this.logger));
     }
     static migrateAdaptableState(state, config) {
         const upgradeHelper = new AdaptableUpgradeHelper(config.logger);
@@ -29,16 +34,16 @@ export class AdaptableUpgradeHelper {
         let updatedState = structuredClone(state);
         for (const version of versionUpgrades) {
             if (version > fromVersion && version <= toVersion) {
-                upgradeHelper.logger.info(`Migration to ${version} started...`);
+                upgradeHelper.logger.info(`Migration to version ${version} started.`);
                 updatedState = upgradeHelper.versionUpgrades.get(version).migrateState(updatedState);
-                upgradeHelper.logger.info(`Migration to ${version} finished!`);
+                upgradeHelper.logger.info(`Migration to version ${version} completed.`);
             }
         }
         return updatedState;
     }
     getCurrentMajorVersion(version) {
         // is good enough for now, we just need to make sure we don't forget to update it
-        return parseInt(version.split('.')[0]) || 20;
+        return parseInt(version.split('.')[0]) || 22;
     }
     getConsoleLogger() {
         return {

package/src/migration/VersionUpgrade.js

@@ -1,4 +1,5 @@
 export class VersionUpgrade {
+    logger;
     constructor(logger) {
         this.logger = logger;
     }

package/src/migration/VersionUpgrade17.js

@@ -98,7 +98,7 @@ export class VersionUpgrade17 extends VersionUpgrade {
         // let dashboardState: any = this.api.dashboardApi.getDashboardState();
         let dashboardState = state.Dashboard;
         if (dashboardState?.VisibleButtons) {
-            this.logger.warn(`Updating Obsolete VisibleButtons Config for DashboardState: [${dashboardState.VisibleButtons}]`);
+            this.logger.warn(`Migrating deprecated DashboardState.VisibleButtons: [${dashboardState.VisibleButtons}].`);
             state.Dashboard.ModuleButtons = [
                 ...state.Dashboard.ModuleButtons,
                 ...dashboardState.VisibleButtons,
@@ -241,12 +241,11 @@ export class VersionUpgrade17 extends VersionUpgrade {
         return state;
     }
     migrateStyledColumnState(state) {
-        var _a;
         const formatColumnsWithColumnStyles = state.FormatColumn?.FormatColumns?.filter((fc) => fc.ColumnStyle) || [];
         if (!formatColumnsWithColumnStyles.length) {
             return state;
         }
-        this.logger.info(`Converting ${formatColumnsWithColumnStyles.length} FormatColumns Styles to Styled Columns`, formatColumnsWithColumnStyles);
+        this.logger.info(`Migrating ${formatColumnsWithColumnStyles.length} FormatColumn styles to StyledColumns.`, formatColumnsWithColumnStyles);
         // delete the format columns with column styles
         state.FormatColumn.FormatColumns = state.FormatColumn.FormatColumns?.filter((fc) => !fc.ColumnStyle);
         const styledColumns = formatColumnsWithColumnStyles
@@ -261,7 +260,7 @@ export class VersionUpgrade17 extends VersionUpgrade {
             };
         })
             .filter(Boolean);
-        (_a = state.StyledColumn).StyledColumns ?? (_a.StyledColumns = []);
+        state.StyledColumn.StyledColumns ??= [];
         styledColumns.forEach((styledColumn) => {
             state.StyledColumn.StyledColumns.push(styledColumn);
         });
@@ -274,7 +273,7 @@ export class VersionUpgrade17 extends VersionUpgrade {
         const deprecatedToolPanelConfigs = state.ToolPanel
             ?.VisibleToolPanels;
         if (deprecatedToolPanelConfigs?.length) {
-            this.logger.warn(`Updating Obsolete VisibleToolPanels Config for ToolPanelState: [${deprecatedToolPanelConfigs}]`);
+            this.logger.warn(`Migrating deprecated ToolPanelState.VisibleToolPanels: [${deprecatedToolPanelConfigs}].`);
             const migratedToolPanelConfigs = deprecatedToolPanelConfigs.map((toolPanel) => ({
                 Name: toolPanel,
                 State: 'collapsed',
@@ -337,7 +336,7 @@ export class VersionUpgrade17 extends VersionUpgrade {
                 cc.CalculatedColumnSettings = {
                     DataType: 'number',
                 };
-                this.logger.warn(`Updating incorrect Initial State for Calculated Column: ${cc.ColumnId}`);
+                this.logger.warn(`Migrating Calculated Column "${cc.ColumnId}": adding default CalculatedColumnSettings.`);
             }
         });
         return state;

package/src/migration/VersionUpgrade20.js

@@ -149,7 +149,7 @@ export class VersionUpgrade20 extends VersionUpgrade {
         return state;
     }
     migrateColTypeToDataType(state) {
-        this.logger.info(`Converting previous column types to new data types`);
+        this.logger.info('Migrating column types to data types.');
         // Calculated Column DataType
         const calculatedColumnState = state.CalculatedColumn;
         if (calculatedColumnState && calculatedColumnState.CalculatedColumns) {
@@ -160,7 +160,7 @@ export class VersionUpgrade20 extends VersionUpgrade {
                     }
                     const newDataType = mapOldTypeToDataType(cc.CalculatedColumnSettings.DataType);
                     if (newDataType === 'unknown') {
-                        this.logger.warn(`Calculated Column ${cc.ColumnId} has an unknown DataType: ${cc.CalculatedColumnSettings.DataType}`);
+                        this.logger.warn(`Calculated Column "${cc.ColumnId}" has unrecognized DataType: "${cc.CalculatedColumnSettings.DataType}".`);
                     }
                     else {
                         cc.CalculatedColumnSettings.DataType = newDataType;
@@ -178,7 +178,7 @@ export class VersionUpgrade20 extends VersionUpgrade {
                     }
                     const newDataType = mapOldTypeToDataType(fc.FreeTextColumnSettings.DataType);
                     if (newDataType === 'unknown') {
-                        this.logger.warn(`FreeText Column ${fc.ColumnId} has an unknown DataType: ${fc.FreeTextColumnSettings.DataType}`);
+                        this.logger.warn(`FreeText Column "${fc.ColumnId}" has unrecognized DataType: "${fc.FreeTextColumnSettings.DataType}".`);
                     }
                     else {
                         fc.FreeTextColumnSettings.DataType = newDataType;
@@ -188,7 +188,7 @@ export class VersionUpgrade20 extends VersionUpgrade {
         }
     }
     migrateSparklineState(state) {
-        this.logger.info(`Migration of Sparkline State`);
+        this.logger.info('Migrating Sparkline state.');
         const sparklineState = state.StyledColumn;
         if (sparklineState && sparklineState.StyledColumns) {
             sparklineState.StyledColumns.forEach((styledColumn) => {

package/src/migration/VersionUpgrade22.d.ts

@@ -0,0 +1,21 @@
+import { VersionUpgrade } from './VersionUpgrade';
+import { AdaptableState } from '../AdaptableState/AdaptableState';
+export declare class VersionUpgrade22 extends VersionUpgrade {
+    migrateState(state: AdaptableState): AdaptableState;
+    private migrateNamedObjectState;
+    private migrateFormatColumnState;
+    private patchCustomSortName;
+    private patchFlashingCellName;
+    private patchFormatColumnName;
+    private patchPlusMinusNudgeName;
+    private patchShortcutName;
+    private patchAlertName;
+    private patchScheduleName;
+    private scopeToString;
+    private hashStrings;
+    /**
+     * Stringifies an object after removing metadata properties (Uuid, Source, AdaptableVersion)
+     * to ensure deterministic hashing regardless of generated values.
+     */
+    private stringifyWithoutMetadata;
+}

package/src/migration/VersionUpgrade22.js

@@ -0,0 +1,187 @@
+import { VersionUpgrade } from './VersionUpgrade';
+import { removeAdaptableObjectPrimitivesInlineDeep } from '../Utilities/Helpers/AdaptableHelper';
+export class VersionUpgrade22 extends VersionUpgrade {
+    migrateState(state) {
+        this.migrateFormatColumnState(state);
+        this.migrateNamedObjectState(state);
+        return state;
+    }
+    migrateNamedObjectState(state) {
+        this.patchCustomSortName(state.CustomSort);
+        this.patchFlashingCellName(state.FlashingCell);
+        this.patchFormatColumnName(state.FormatColumn);
+        this.patchPlusMinusNudgeName(state.PlusMinus);
+        this.patchShortcutName(state.Shortcut);
+        this.patchAlertName(state.Alert);
+        this.patchScheduleName(state.Schedule);
+    }
+    // We have moved CellAlignment (renamed Alignment) from independent property into Style
+    migrateFormatColumnState(state) {
+        const formatColumnState = state.FormatColumn;
+        if (formatColumnState && formatColumnState.FormatColumns) {
+            formatColumnState.FormatColumns = formatColumnState.FormatColumns.map((formatColumn) => {
+                //@ts-ignore
+                if (formatColumn.CellAlignment) {
+                    formatColumn.Style = {
+                        ...formatColumn.Style,
+                        //@ts-ignore
+                        Alignment: formatColumn.CellAlignment,
+                    };
+                    //@ts-ignore
+                    delete formatColumn.CellAlignment;
+                }
+                return formatColumn;
+            });
+        }
+        return state;
+    }
+    patchCustomSortName(customSortState) {
+        if (!customSortState) {
+            return;
+        }
+        customSortState.CustomSorts?.forEach((customSort) => {
+            if (!customSort.Name) {
+                const sortedValues = (customSort.SortedValues || []).join();
+                customSort.Name = `CustomSort-${customSort.ColumnId}-${this.hashStrings(['CustomSort', customSort.ColumnId, sortedValues])}`;
+            }
+        });
+    }
+    patchFlashingCellName(flashingCellState) {
+        if (!flashingCellState) {
+            return;
+        }
+        flashingCellState.FlashingCellDefinitions?.forEach((flashingCell) => {
+            if (!flashingCell.Name) {
+                const scopeStr = this.scopeToString(flashingCell.Scope);
+                const ruleStr = flashingCell.Rule?.BooleanExpression || '';
+                flashingCell.Name = `FlashingCell-${this.hashStrings(['FlashingCell', scopeStr, ruleStr])}`;
+            }
+        });
+    }
+    patchFormatColumnName(formatColumnState) {
+        if (!formatColumnState) {
+            return;
+        }
+        formatColumnState.FormatColumns?.forEach((formatColumn) => {
+            if (!formatColumn.Name) {
+                const scopeStr = this.scopeToString(formatColumn.Scope);
+                const styleStr = this.stringifyWithoutMetadata(formatColumn.Style);
+                formatColumn.Name = `FormatColumn-${this.hashStrings(['FormatColumn', scopeStr, styleStr])}`;
+            }
+        });
+    }
+    patchPlusMinusNudgeName(plusMinusState) {
+        if (!plusMinusState) {
+            return;
+        }
+        plusMinusState.PlusMinusNudges?.forEach((nudge) => {
+            if (!nudge.Name) {
+                const scopeStr = this.scopeToString(nudge.Scope);
+                const nudgeValue = String(nudge.NudgeValue ?? '');
+                nudge.Name = `PlusMinus-${this.hashStrings(['PlusMinus', scopeStr, nudgeValue])}`;
+            }
+        });
+    }
+    patchShortcutName(shortcutState) {
+        if (!shortcutState) {
+            return;
+        }
+        shortcutState.Shortcuts?.forEach((shortcut) => {
+            if (!shortcut.Name) {
+                const key = shortcut.ShortcutKey || '';
+                const operation = shortcut.ShortcutOperation || '';
+                const value = String(shortcut.ShortcutValue ?? '');
+                shortcut.Name = `Shortcut-${key}-${this.hashStrings(['Shortcut', key, operation, value])}`;
+            }
+        });
+    }
+    patchAlertName(alertState) {
+        if (!alertState) {
+            return;
+        }
+        alertState.AlertDefinitions?.forEach((alert) => {
+            if (!alert.Name) {
+                const scopeStr = this.scopeToString(alert.Scope);
+                const messageType = alert.MessageType || '';
+                const ruleStr = this.stringifyWithoutMetadata(alert.Rule);
+                alert.Name = `Alert-${messageType}-${this.hashStrings(['Alert', scopeStr, messageType, ruleStr])}`;
+            }
+        });
+    }
+    patchScheduleName(scheduleState) {
+        if (!scheduleState) {
+            return;
+        }
+        // Patch Reminder Schedules
+        scheduleState.Reminders?.forEach((reminder) => {
+            if (!reminder.Name) {
+                const header = reminder.Header || '';
+                const message = reminder.Message || '';
+                reminder.Name = `Reminder-${this.hashStrings(['Reminder', header, message])}`;
+            }
+        });
+        // Patch Report Schedules
+        scheduleState.ReportSchedules?.forEach((report) => {
+            if (!report.Name) {
+                const reportName = report.ReportName || '';
+                const format = report.ReportFormat || '';
+                report.Name = `ReportSchedule-${this.hashStrings(['ReportSchedule', reportName, format])}`;
+            }
+        });
+        // Patch IPushPull Schedules
+        scheduleState.IPushPullSchedules?.forEach((ipp) => {
+            if (!ipp.Name) {
+                const reportName = ipp.IPushPullReport?.ReportName || '';
+                const folder = ipp.IPushPullReport?.Folder || '';
+                const page = ipp.IPushPullReport?.Page || '';
+                ipp.Name = `IPushPullSchedule-${this.hashStrings(['IPushPullSchedule', reportName, folder, page])}`;
+            }
+        });
+        // Patch OpenFin Schedules
+        scheduleState.OpenFinSchedules?.forEach((openfin) => {
+            if (!openfin.Name) {
+                const reportName = openfin.OpenFinReport?.ReportName || '';
+                openfin.Name = `OpenFinSchedule-${this.hashStrings(['OpenFinSchedule', reportName])}`;
+            }
+        });
+    }
+    scopeToString(scope) {
+        if (!scope) {
+            return '';
+        }
+        if ('All' in scope && scope.All) {
+            return 'All';
+        }
+        if ('ColumnIds' in scope && scope.ColumnIds) {
+            return scope.ColumnIds.join(',');
+        }
+        if ('DataTypes' in scope && scope.DataTypes) {
+            return scope.DataTypes.join(',');
+        }
+        if ('ColumnTypes' in scope && scope.ColumnTypes) {
+            return scope.ColumnTypes.join(',');
+        }
+        return '';
+    }
+    hashStrings(strings) {
+        let hash = 0;
+        for (const str of strings) {
+            for (let i = 0; i < str.length; i++) {
+                hash = (hash * 31 + str.charCodeAt(i)) % 9000;
+            }
+        }
+        return hash + 1000;
+    }
+    /**
+     * Stringifies an object after removing metadata properties (Uuid, Source, AdaptableVersion)
+     * to ensure deterministic hashing regardless of generated values.
+     */
+    stringifyWithoutMetadata(obj) {
+        if (!obj) {
+            return '';
+        }
+        const cloned = structuredClone(obj);
+        removeAdaptableObjectPrimitivesInlineDeep(cloned);
+        return JSON.stringify(cloned);
+    }
+}

package/src/parser/src/ExpressionEvaluationError.js

@@ -1,4 +1,5 @@
 export class ExpressionEvaluationError extends Error {
+    expressionFnName;
     constructor(expressionFnName, message) {
         super(message);
         this.expressionFnName = expressionFnName;

package/src/types.d.ts

@@ -10,7 +10,7 @@ export type { AggregatedBooleanFunctionName } from './Utilities/ExpressionFuncti
 export type { AggregatedScalarFunctionName } from './Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions';
 export type { AdaptableOptions } from './AdaptableOptions/AdaptableOptions';
 export { AdaptablePlugin } from './AdaptableOptions/AdaptablePlugin';
-export type { ContainerOptions } from './AdaptableOptions/ContainerOptions';
+export type { ContainerOptions, AdaptableContainerValue, AdaptableCSSSelector, InitContainerContext, ContainerContext, } from './AdaptableOptions/ContainerOptions';
 export type { FlashingCellOptions, FlashTarget } from './AdaptableOptions/FlashingCellOptions';
 export type { ToastPositions, ToastTransitions, NotificationsOptions, } from './AdaptableOptions/NotificationsOptions';
 export type { AlertOptions, CommandHandler, AlertForm, AlertFormContext, AlertMessageContext, DataChangeDetectionPolicy, } from './AdaptableOptions/AlertOptions';
@@ -141,7 +141,7 @@ export type { ScheduleTriggeredInfo } from './Api/Events/ScheduleTriggered';
 export type { AdaptableStateChangedInfo } from './Api/Events/AdaptableStateChanged';
 export type { CommentChangedInfo } from './Api/Events/CommentChanged';
 export type { Fdc3MessageInfo, Fdc3MessageSentInfo, Fdc3MessageReceivedInfo, } from './Api/Events/Fdc3MessageInfo';
-export type { AdaptableState, AdaptablePersistentState } from './AdaptableState/AdaptableState';
+export type { AdaptableState, AdaptablePersistentState, AdaptableTransientState, } from './AdaptableState/AdaptableState';
 export type { AlertDefinition, AlertProperties, AlertState, AlertButtonForm, AlertButton, AdaptableAlertCommand, AlertDefinitionPredicate, AlertRule, AdaptableAlertQuery, SystemAlertPredicateId, SystemAlertPredicateIds, } from './AdaptableState/AlertState';
 export type { ApplicationDataEntry, ApplicationState } from './AdaptableState/ApplicationState';
 export type { SpecialColumnSettings } from './AdaptableState/Common/SpecialColumnSettings';
@@ -150,15 +150,14 @@ export type { CellSummmaryInfo, CustomCellSummaryOperation, CustomCellSummaryOpe
 export type { FlashingCellDefinition, FlashingCellState, SystemFlashingCellPredicateId, SystemFlashingCellPredicateIds, } from './AdaptableState/FlashingCellState';
 export type { AdaptableAlert, AdaptableAlertType, AdaptableGenericAlert, AdaptableCellChangedAlert, AdaptableRowChangedAlert, AdaptableAlertBase, } from './AdaptableState/Common/AdaptableAlert';
 export type { AdaptableFlashingCell } from './AdaptableState/Common/AdaptableFlashingCell';
-export type { AdaptableColumn, AdaptableColumnBase, AdaptableColumnType, AdaptableColumnDataType, AdaptableColumnGroup, AdaptableColumnSummary, } from './AdaptableState/Common/AdaptableColumn';
+export type { AdaptableColumn, AdaptableColumnBase, AdaptableColumnTypeName, AdaptableColumnDataType, AdaptableColumnGroup, AdaptableColumnSummary, } from './AdaptableState/Common/AdaptableColumn';
 export type { AdaptableField } from './AdaptableState/Common/AdaptableField';
 export type { AdaptableComparerFunction } from './AdaptableState/Common/AdaptableComparerFunction';
 export type { SystemStatusMessageInfo } from './AdaptableState/Common/SystemStatusMessageInfo';
 export type { AlternativeModuleName } from './AdaptableState/Common/AlternativeModuleName';
 export type { AdaptableFormat, DateFormatterOptions, NumberFormatterOptions, StringFormatterOptions, } from './AdaptableState/Common/AdaptableFormat';
 export type { AdaptableMessageType } from './AdaptableState/Common/AdaptableMessageType';
-export type { AdaptableObject, AdaptableObjectTag, AdaptableObjectLookupCriteria, AdaptableVersion, } from './AdaptableState/Common/AdaptableObject';
-export type { SuspendableObject } from './AdaptableState/Common/SuspendableObject';
+export type { Identifiable, AdaptableObject, AdaptableObjectTag, AdaptableObjectLookupCriteria, AdaptableVersion, SuspendableObject, } from './AdaptableState/Common/AdaptableObject';
 export type { AdaptableQuery, AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery, AdaptableBooleanQuery, AdaptableObservableQuery, AdaptableScalarQuery, } from './AdaptableState/Common/AdaptableQuery';
 export type { AdaptablePredicate, AdaptableColumnPredicate, AdaptablePredicateDef, PredicateModuleScope, PredicateDefHandlerContext, PredicateDefInput, PredicateDefToStringParams, ColumnFilterDef, } from './AdaptableState/Common/AdaptablePredicate';
 export type { ColumnScope } from './AdaptableState/Common/ColumnScope';
@@ -173,11 +172,13 @@ export type { CellDataChangedInfo } from './AdaptableState/Common/CellDataChange
 export type { RowDataChangedInfo, RowDataChangeTrigger, } from './AdaptableState/Common/RowDataChangedInfo';
 export type { DataChangedScope } from './AdaptableState/Common/DataChangedScope';
 export type { DataUpdateConfig } from './AdaptableState/Common/DataUpdateConfig';
+export type { DataRowConfig } from './AdaptableState/Common/DataUpdateConfig';
 export type { AdaptableFormData, AdaptableForm, AdaptableFormField, AdaptableFormFieldType, } from './AdaptableState/Common/AdaptableForm';
 export type { AdaptableButton } from './AdaptableState/Common/AdaptableButton';
 export type { AdaptableMenuItem, UserMenuItem, ColumnMenuContext, ContextMenuContext, AdaptableContextMenuItem, AdaptableColumnMenuItem, AdaptableColumnMenuItemName, AdaptableContextMenuItemName, AgGridMenuItem, MenuCategory, MenuSeparator, } from './AdaptableState/Common/Menu';
 export type { BaseContext } from './AdaptableState/Common/BaseContext';
-export type { AdaptableColumnContext } from './AdaptableState/Common/AdaptableColumnContext';
+export type { AdaptableColumnContext, AdaptableColumnsContext, } from './AdaptableState/Common/AdaptableColumnContext';
+export type { AdaptableRowContext } from './AdaptableState/Common/AdaptableRowContext';
 export type { FormContext } from './AdaptableState/Common/FormContext';
 export type { Schedule } from './AdaptableState/Common/Schedule';
 export type { ButtonStyle } from './AdaptableState/Common/ButtonStyle';
@@ -188,7 +189,7 @@ export type { DashboardState, DashboardTab, AdaptableCoordinate, } from './Adapt
 export type { ExportState, Report, ReportData, ReportColumn, ReportSchedule, SystemReportName, SystemReportNames, SystemReportFormat, ReportRowScope, ReportColumnScope, ReportNameType, ReportFormatType, } from './AdaptableState/ExportState';
 export type { ColumnFilter, ColumnFilterPredicate, SystemFilterPredicateIds, SystemFilterPredicateId, PredicatesOperator, } from './AdaptableState/Common/ColumnFilter';
 export type { GridFilter } from './AdaptableState/Common/GridFilter';
-export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, CellAlignment, ColumnGroupScope, FormatColumnTarget, FormatColumnConfig, } from './AdaptableState/FormatColumnState';
+export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, ColumnGroupScope, FormatColumnTarget, FormatColumnConfig, } from './AdaptableState/FormatColumnState';
 export type { StyledColumn, StyledColumnState, PercentBarStyle, GradientStyle, CellColorRange, ColumnComparison, CellTextOptions, CellTextOption, NumericStyledColumn, RangeValueType, SparklineStyle, BadgeStyle, BadgeStyleDefinition, BadgeStylePredicate, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, } from './AdaptableState/StyledColumnState';
 export type { FreeTextColumn, FreeTextColumnState, FreeTextStoredValue, FreeTextColumnSettings, } from './AdaptableState/FreeTextColumnState';
 export type { StatusBarState, AdaptableStatusBar } from './AdaptableState/StatusBarState';
@@ -210,6 +211,7 @@ export type { Shortcut, ShortcutState, ShortcutScopeDataType, } from './Adaptabl
 export type { SharedEntity, AdaptableSharedEntity, CustomSharedEntity, TeamSharingState, SharedEntityType, AdaptableSharedEntityConfig, CustomSharedEntityConfig, } from './AdaptableState/TeamSharingState';
 export type { AdaptableTheme, ThemeState } from './AdaptableState/ThemeState';
 export type { ToolPanelState, AdaptableToolPanelDefinition, ToolPanelVisibilityMode, } from './AdaptableState/ToolPanelState';
+export type { UserInterfaceState } from './AdaptableState/UserInterfaceState';
 export type { AdaptableFrameworkComponent, AngularFrameworkComponent, ReactFrameworkComponent, VueFrameworkComponent, CustomRenderFunction, CustomRenderContext, } from './agGrid/AdaptableFrameworkComponent';
 export type { Fdc3Options, GridDataContextMapping, ActionColumnDefaultConfiguration, ResolveContextDataContext, RaiseIntentConfig, BroadcastConfig, HandleFdc3IntentContext, HandleFdc3Context, Fdc3ButtonContext, Fdc3AdaptableButton, HandleFdc3IntentResolutionContext, UIControlConfig, Fdc3IntentOptions, Fdc3ContextOptions, RaiseIntentConfiguration, BroadcastConfiguration, FDC3ActionColumn, } from './AdaptableOptions/Fdc3Options';
 export type { CommentState, CommentThread, AdaptableComment } from './AdaptableState/CommentState';

package/themes/dark.css

@@ -1,35 +1,35 @@
-.ab--theme-dark {
-  --ab-theme-loaded: dark;
+@layer adaptable.theme {
+  .ab--theme-dark {
+    --ab-theme-loaded: dark;
 
-  --ab-cmp-input--disabled__background: #232323; /* #b6b7b8 */
+    --ab-cmp-input--disabled__background: #232323; /* #b6b7b8 */
 
-  --ab-color-defaultbackground: #3e444c;
-  --ab-color-text-on-defaultbackground: #e2e2e2;
+    --ab-color-defaultbackground: #3e444c;
+    --ab-color-text-on-defaultbackground: #e2e2e2;
 
-  --ab-color-primary: #262d2f;
-  --ab-color-primarylight: #3d3e3f;
-  --ab-color-primarydark: #1c2021;
-  --ab-color-text-on-primary: #e2e2e2; /* F2F2F2 */
+    --ab-color-primary: #262d2f;
+    --ab-color-primarylight: #3d3e3f;
+    --ab-color-primarydark: #1c2021;
+    --ab-color-text-on-primary: #e2e2e2; /* F2F2F2 */
 
-  --ab-color-shadow: rgb(255 255 255 / 0.45);
-  --ab-cmp-modal-backdrop__background: rgba(255, 255, 255, 0.2);
+    --ab-color-shadow: rgb(255 255 255 / 0.45);
+    --ab-cmp-modal-backdrop__background: rgba(255, 255, 255, 0.2);
 
-  --ab-dashboard__border: #555;
-  --ab-cmp-dropdownbutton-list-separator__border: 1px solid #555;
+    --ab-dashboard__border: #555;
+    --ab-cmp-dropdownbutton-list-separator__border: 1px solid #555;
 
-  --ab-gridheader--filtered__background: var(--ab-color-defaultbackground);
+    --ab-gridheader--filtered__background: var(--ab-color-defaultbackground);
 
-  --ab-cmp-checkbox__border-color: var(--ab-color-text-on-primary);
-  --ab-cmp-checkbox--checked__border-color: var(--ab-color-accent);
-
-  input[type='number'].ab-Input::-webkit-outer-spin-button,
-  input[type='number'].ab-Input::-webkit-inner-spin-button {
-    background: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="18" height="20" viewBox="4 0 18 18" version="1.1"><path fill="%23f7f7f7" d="M7 10l5 5 5-5z" transform="translate(0, 2)"/><path fill="%23f7f7f7" d="M7 14l5-5 5 5z" transform="translate(0, -6)"/></svg>')
-      no-repeat center center;
+    --ab-cmp-checkbox__border-color: var(--ab-color-text-on-primary);
+    --ab-cmp-checkbox--checked__border-color: var(--ab-color-accent);
   }
-}
 
-/*
+    .ab--theme-dark input.ab-Input[type='number']::-webkit-outer-spin-button,.ab--theme-dark input.ab-Input[type='number']::-webkit-inner-spin-button {
+      background: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="18" height="20" viewBox="4 0 18 18" version="1.1"><path fill="%23f7f7f7" d="M7 10l5 5 5-5z" transform="translate(0, 2)"/><path fill="%23f7f7f7" d="M7 14l5-5 5 5z" transform="translate(0, -6)"/></svg>')
+        no-repeat center center;
+    }
+
+  /*
 The following are only redefined here so that the DARK theme in Storybook
 can be previewed correctly as that relies on an element (not the document element)
 to have the class ab--theme-dark.
@@ -38,11 +38,11 @@ For our production release those are not needed and could be removed
 as our dark theme is anyways applied on the document element.
 
 */
-.ab--theme-dark {
-  --ab-color-inputcolor: var(--ab-color-text-on-primary);
-  --ab-cmp-input__color: var(--ab-color-inputcolor);
-  --ab-cmp-input__background: var(--ab-color-defaultbackground);
-  --ab-cmp-input--disabled__background: var(--ab-color-primarylight);
-  --ab-cmp-field-wrap__background: var(--ab-color-defaultbackground);
-  --ab-cmp-simple-button--outlined__background: var(--ab-color-defaultbackground);
+  .ab--theme-dark {
+    --ab-color-inputcolor: var(--ab-color-text-on-primary);
+    --ab-cmp-input__color: var(--ab-color-inputcolor);
+    --ab-cmp-input__background: var(--ab-color-defaultbackground);
+    --ab-cmp-input--disabled__background: var(--ab-color-primarylight);
+    --ab-cmp-field-wrap__background: var(--ab-color-defaultbackground);
+  }
 }

package/themes/light.css

@@ -1,3 +1,5 @@
-html.ab--theme-light {
-  --ab-theme-loaded: light;
+@layer adaptable.theming {
+  html.ab--theme-light {
+    --ab-theme-loaded: light;
+  }
 }