@adaptabletools/adaptable-cjs 22.0.0-canary.0 → 22.0.0-canary.10

package/src/migration/AdaptableUpgradeHelper.js

@@ -6,7 +6,11 @@ const VersionUpgrade18_1 = require("./VersionUpgrade18");
 const EnvVars_1 = require("../EnvVars");
 const VersionUpgrade20_1 = require("./VersionUpgrade20");
 const VersionUpgrade21_1 = require("./VersionUpgrade21");
+const VersionUpgrade22_1 = require("./VersionUpgrade22");
 class AdaptableUpgradeHelper {
+    currentMajorVersion;
+    versionUpgrades;
+    logger;
     constructor(logger) {
         this.currentMajorVersion = this.getCurrentMajorVersion(EnvVars_1.ADAPTABLE_VERSION);
         this.logger = logger || this.getConsoleLogger();
@@ -15,6 +19,7 @@ class AdaptableUpgradeHelper {
         this.versionUpgrades.set(18, new VersionUpgrade18_1.VersionUpgrade18(this.logger));
         this.versionUpgrades.set(20, new VersionUpgrade20_1.VersionUpgrade20(this.logger));
         this.versionUpgrades.set(21, new VersionUpgrade21_1.VersionUpgrade21(this.logger));
+        this.versionUpgrades.set(22, new VersionUpgrade22_1.VersionUpgrade22(this.logger));
     }
     static migrateAdaptableState(state, config) {
         const upgradeHelper = new AdaptableUpgradeHelper(config.logger);
@@ -32,16 +37,16 @@ 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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionUpgrade = void 0;
 class VersionUpgrade {
+    logger;
     constructor(logger) {
         this.logger = logger;
     }

package/src/migration/VersionUpgrade17.js

@@ -102,7 +102,7 @@ class VersionUpgrade17 extends VersionUpgrade_1.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,
@@ -245,12 +245,11 @@ class VersionUpgrade17 extends VersionUpgrade_1.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
@@ -265,7 +264,7 @@ class VersionUpgrade17 extends VersionUpgrade_1.VersionUpgrade {
             };
         })
             .filter(Boolean);
-        (_a = state.StyledColumn).StyledColumns ?? (_a.StyledColumns = []);
+        state.StyledColumn.StyledColumns ??= [];
         styledColumns.forEach((styledColumn) => {
             state.StyledColumn.StyledColumns.push(styledColumn);
         });
@@ -278,7 +277,7 @@ class VersionUpgrade17 extends VersionUpgrade_1.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',
@@ -341,7 +340,7 @@ class VersionUpgrade17 extends VersionUpgrade_1.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

@@ -153,7 +153,7 @@ class VersionUpgrade20 extends VersionUpgrade_1.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) {
@@ -164,7 +164,7 @@ class VersionUpgrade20 extends VersionUpgrade_1.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;
@@ -182,7 +182,7 @@ class VersionUpgrade20 extends VersionUpgrade_1.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;
@@ -192,7 +192,7 @@ class VersionUpgrade20 extends VersionUpgrade_1.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,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionUpgrade22 = void 0;
+const VersionUpgrade_1 = require("./VersionUpgrade");
+const AdaptableHelper_1 = require("../Utilities/Helpers/AdaptableHelper");
+class VersionUpgrade22 extends VersionUpgrade_1.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);
+        (0, AdaptableHelper_1.removeAdaptableObjectPrimitivesInlineDeep)(cloned);
+        return JSON.stringify(cloned);
+    }
+}
+exports.VersionUpgrade22 = VersionUpgrade22;

package/src/parser/src/ExpressionEvaluationError.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressionEvaluationError = void 0;
 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;
+  }
 }