@adaptabletools/adaptable 22.1.1 → 23.0.0-canary.0

package/src/setupDevTools.js

@@ -0,0 +1,410 @@
+import { AG_GRID_VERSION } from './agGrid/AgGridModulesAdapter';
+import { ADAPTABLE_VERSION } from './EnvVars';
+import Emitter from './Utilities/Emitter';
+import { debug } from '@infinite-table/infinite-react';
+import { warnOnce } from './agGrid/AdaptableLogger';
+let DEV_TOOLS_LISTENING_STARTED = false;
+let DEV_TOOLS_READY = false;
+const __ADAPTABLE_DEVTOOLS_EMITTER = new Emitter();
+const LOG_LEVELS = ['info', 'success', 'warn', 'error', 'perf'];
+function serializeForPostMessage(value) {
+    try {
+        const json = JSON.stringify(value);
+        return json === undefined ? String(value) : JSON.parse(json);
+    }
+    catch (error) {
+        console.warn('Adaptable DevTools: error serializing value', error);
+        // Circular references or non-serializable values — serialize with cycle pruning.
+        const seen = new WeakSet();
+        const json = JSON.stringify(value, (_key, val) => {
+            if (typeof val === 'object' && val !== null) {
+                if (seen.has(val))
+                    return undefined;
+                seen.add(val);
+            }
+            return val;
+        });
+        return json === undefined ? String(value) : JSON.parse(json);
+    }
+}
+function serializeAdaptableStateForPostMessage(state, parentKey) {
+    return Object.entries(state).reduce((acc, [key, value]) => {
+        if (key === 'Internal') {
+            acc[key] = serializeAdaptableStateForPostMessage(value, key);
+            return acc;
+        }
+        try {
+            const json = JSON.stringify(value);
+            acc[key] = json === undefined ? String(value) : JSON.parse(json);
+        }
+        catch (_error) {
+            warnOnce(`Adaptable DevTools: skipping serializing state key "${parentKey ? `${parentKey}.` : ''}${key}"`);
+            // acc[key] = String(value);
+        }
+        return acc;
+    }, {});
+}
+function formatLogArgForPostMessage(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value == null) {
+        return String(value);
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+function isMessageFromDevToolsContentScript(data) {
+    return (data &&
+        typeof data.source === 'string' &&
+        typeof data.target === 'string' &&
+        data.target === 'adaptable-page' &&
+        data.source.startsWith('adaptable-devtools-contentscript'));
+}
+function ensureDevToolsReady() {
+    if (DEV_TOOLS_READY) {
+        return Promise.resolve();
+    }
+    DEV_TOOLS_READY = true;
+    console.log('Adaptable DevTools is listening for messages!');
+    debug.onLogIntent('*', (logOptions) => {
+        const { channel, color, timestamp, args } = logOptions;
+        const channelParts = channel.split(':');
+        const [channelBase, adaptableId] = channelParts;
+        if (!['Adaptable', 'LayoutManager'].includes(channelBase)) {
+            return;
+        }
+        if (channelBase === 'LayoutManager' && adaptableId === 'Diffing') {
+            return;
+        }
+        if (!adaptableId) {
+            return;
+        }
+        window.postMessage({
+            ...messageBase,
+            url: getPageUrlOfWindow(),
+            type: 'log',
+            payload: {
+                adaptableId,
+                channel,
+                color,
+                level: channelParts.find((part) => LOG_LEVELS.includes(part)) ?? 'info',
+                timestamp,
+                args: args.map((arg) => serializeForPostMessage(formatLogArgForPostMessage(arg))),
+            },
+        });
+    });
+    return __ADAPTABLE_DEVTOOLS_EMITTER.emit('ready');
+}
+function handleOpenSettingsPanelMessage(payload) {
+    const { adaptableId, moduleName } = payload ?? {};
+    if (!adaptableId) {
+        console.warn('Adaptable DevTools: open-settings-panel message missing adaptableId');
+        return;
+    }
+    const instance = REGISTERED_ADAPTABLE_INSTANCES.get(adaptableId);
+    if (instance?.isDestroyed) {
+        console.warn(`Adaptable DevTools: instance "${adaptableId}" is destroyed; cannot open settings panel`);
+        return;
+    }
+    const api = instance?.api ?? REGISTERED_ADAPTABLE_APIS.get(adaptableId);
+    const settingsPanelApi = api?.settingsPanelApi;
+    if (!settingsPanelApi) {
+        console.warn(`Adaptable DevTools: settings panel is not available for "${adaptableId}" (instance not ready or destroyed)`);
+        return;
+    }
+    settingsPanelApi.openSettingsPanel(moduleName);
+}
+function applyThemeToDocumentElement(payload) {
+    const style = document.documentElement.style;
+    for (let i = style.length - 1; i >= 0; i--) {
+        const prop = style[i];
+        if (prop.startsWith('--ab-')) {
+            style.removeProperty(prop);
+        }
+    }
+    for (const [name, value] of Object.entries(payload.light)) {
+        if (value != null && value !== '') {
+            style.setProperty(name, String(value));
+        }
+    }
+    if (payload.variant === 'dark') {
+        for (const [name, value] of Object.entries(payload.dark)) {
+            if (value != null && value !== '') {
+                style.setProperty(name, String(value));
+            }
+        }
+    }
+}
+function handleThemeVarChangeMessage(payload) {
+    const { name, value } = payload ?? {};
+    if (!name) {
+        return;
+    }
+    document.documentElement.style.setProperty(name, String(value ?? ''));
+}
+function handleApplyThemeMessage(payload) {
+    if (!payload || (payload.variant !== 'light' && payload.variant !== 'dark')) {
+        return;
+    }
+    applyThemeToDocumentElement(payload);
+}
+function handleLoadVariantMessage(payload) {
+    const { adaptableId, variant } = payload ?? {};
+    if (!adaptableId || (variant !== 'light' && variant !== 'dark')) {
+        console.warn('Adaptable DevTools: load-variant message missing adaptableId or variant');
+        return;
+    }
+    const api = REGISTERED_ADAPTABLE_APIS.get(adaptableId);
+    if (!api) {
+        console.warn(`Adaptable DevTools: no registered instance for "${adaptableId}"`);
+        return;
+    }
+    console.log(`Adaptable DevTools: loading "${variant}" theme variant for "${adaptableId}"`);
+    if (variant === 'dark') {
+        api.themeApi.loadDarkTheme();
+    }
+    else {
+        api.themeApi.loadLightTheme();
+    }
+}
+function handleRestoreStateMessage(payload) {
+    const { adaptableId, state } = payload ?? {};
+    if (!adaptableId || !state) {
+        console.warn('Adaptable DevTools: restore-state message missing adaptableId or state');
+        return;
+    }
+    const api = REGISTERED_ADAPTABLE_APIS.get(adaptableId);
+    if (!api) {
+        console.warn(`Adaptable DevTools: no registered instance for "${adaptableId}"`);
+        return;
+    }
+    void api.stateApi.internalApi.restoreState(state).catch((error) => {
+        console.error(`Adaptable DevTools: failed to restore state for "${adaptableId}"`, error);
+    });
+}
+export function listenForDevTools(adaptableInstance) {
+    if (typeof window !== 'undefined' && !DEV_TOOLS_LISTENING_STARTED) {
+        DEV_TOOLS_LISTENING_STARTED = true;
+        window.addEventListener('message', (event) => {
+            if (!isMessageFromDevToolsContentScript(event.data)) {
+                return;
+            }
+            void ensureDevToolsReady();
+            const handlers = {
+                'restore-state': handleRestoreStateMessage,
+                'open-settings-panel': handleOpenSettingsPanelMessage,
+                'load-variant': handleLoadVariantMessage,
+                'theme-var-change': handleThemeVarChangeMessage,
+                'apply-theme': handleApplyThemeMessage,
+            };
+            handlers[event.data.type]?.(event.data.payload);
+        });
+    }
+    __ADAPTABLE_DEVTOOLS_EMITTER.onIncludeFiredOnce('ready').then(() => {
+        const { api, adaptableOptions } = adaptableInstance;
+        if (!api || !adaptableOptions) {
+            console.error('Cannot register Adaptable instance in DevTools because it is not ready', adaptableInstance);
+            return;
+        }
+        registerAdaptableInstanceInDevTools(adaptableOptions.adaptableId, { api }, adaptableInstance);
+    });
+}
+const REGISTERED_ADAPTABLE_IDS = new Set();
+const REGISTERED_ADAPTABLE_APIS = new Map();
+const REGISTERED_ADAPTABLE_INSTANCES = new Map();
+/** Grid row counts are read after AG Grid applies filters (see AdaptableStore setTimeout delays). */
+const pendingGridRuntimeUpdates = new Map();
+const GRID_RUNTIME_FALLBACK_DELAY_MS = 100;
+/** Per-instance listener cleanup (remount / strict mode) without notifying the extension. */
+const INSTANCE_REGISTRATIONS = new Map();
+function buildGridRuntime(api) {
+    const selectedRowInfo = api.gridApi.getSelectedRowInfo();
+    return {
+        allRowsCount: api.gridApi.getRowCount(),
+        visibleRowsCount: api.gridApi.getVisibleRowCount(),
+        selectedRowsCount: selectedRowInfo?.gridRows?.length ?? 0,
+    };
+}
+function postMountMessage(adaptableId, api) {
+    window.postMessage(buildMessageForExtension({
+        type: 'mount',
+        adaptableId,
+        adaptableVersion: ADAPTABLE_VERSION,
+        agGridVersion: AG_GRID_VERSION,
+        licenseKey: api.optionsApi.getAdaptableOptions().licenseKey,
+    }));
+}
+function cancelScheduledGridRuntimeUpdate(adaptableId) {
+    const pending = pendingGridRuntimeUpdates.get(adaptableId);
+    if (pending != null) {
+        clearTimeout(pending);
+        pendingGridRuntimeUpdates.delete(adaptableId);
+    }
+}
+function scheduleGridRuntimeUpdate(adaptableId, api, delayMs = GRID_RUNTIME_FALLBACK_DELAY_MS) {
+    cancelScheduledGridRuntimeUpdate(adaptableId);
+    pendingGridRuntimeUpdates.set(adaptableId, setTimeout(() => {
+        pendingGridRuntimeUpdates.delete(adaptableId);
+        postGridRuntimeUpdate(adaptableId, api);
+    }, delayMs));
+}
+function postStateChangeMessage(adaptableId, options) {
+    const api = options?.api ?? REGISTERED_ADAPTABLE_APIS.get(adaptableId);
+    if (!api) {
+        return;
+    }
+    const state = api.stateApi.internalApi.getAllStateForDevTools
+        ? api.stateApi.internalApi.getAllStateForDevTools()
+        : api.stateApi.getAllState();
+    window.postMessage(buildMessageForExtension({
+        type: 'state-change',
+        adaptableId,
+        state: serializeAdaptableStateForPostMessage(state),
+        actionName: options?.actionName,
+    }));
+    if (options?.api) {
+        scheduleGridRuntimeUpdate(adaptableId, options.api);
+    }
+}
+/** Row/selection counts can change without a full AdaptableStateChanged payload in the UI. */
+function postGridRuntimeUpdate(adaptableId, api) {
+    window.postMessage(buildMessageForExtension({
+        type: 'state-change',
+        adaptableId,
+        gridRuntime: buildGridRuntime(api),
+    }));
+}
+function detachAdaptableInstanceListeners(adaptableId) {
+    cancelScheduledGridRuntimeUpdate(adaptableId);
+    const registration = INSTANCE_REGISTRATIONS.get(adaptableId);
+    if (registration) {
+        registration.unsubscribe();
+        INSTANCE_REGISTRATIONS.delete(adaptableId);
+    }
+    REGISTERED_ADAPTABLE_IDS.delete(adaptableId);
+    REGISTERED_ADAPTABLE_APIS.delete(adaptableId);
+    REGISTERED_ADAPTABLE_INSTANCES.delete(adaptableId);
+}
+function unregisterAdaptableInstanceFromDevTools(adaptableId) {
+    detachAdaptableInstanceListeners(adaptableId);
+    window.postMessage(buildMessageForExtension({ type: 'unmount', adaptableId }));
+}
+const messageBase = {
+    source: 'adaptable-page',
+    target: 'adaptable-devtools-background',
+};
+export function getPageUrlOfWindow() {
+    const url = new URL(window.location.href);
+    return url.origin + url.pathname;
+}
+function buildMessageForExtension(params) {
+    const { type, adaptableId, ...payload } = params;
+    const url = getPageUrlOfWindow();
+    if (type === 'unmount') {
+        return {
+            ...messageBase,
+            url,
+            type,
+            payload: {
+                adaptableId,
+                ...(payload ?? {}),
+            },
+        };
+    }
+    if (type === 'mount') {
+        return {
+            ...messageBase,
+            url,
+            type,
+            payload: {
+                adaptableId,
+                adaptableVersion: payload?.adaptableVersion,
+                agGridVersion: payload?.agGridVersion,
+                licenseKey: payload?.licenseKey,
+            },
+        };
+    }
+    if (type === 'state-change') {
+        return {
+            ...messageBase,
+            url,
+            type,
+            payload: {
+                adaptableId,
+                state: payload?.state,
+                actionName: payload?.actionName,
+                gridRuntime: payload?.gridRuntime,
+            },
+        };
+    }
+    const message = {
+        ...messageBase,
+        url,
+        type,
+        payload: {
+            adaptableId,
+            ...(payload ?? {}),
+        },
+    };
+    return message;
+}
+function publishStateSnapshot(adaptableId) {
+    const api = REGISTERED_ADAPTABLE_APIS.get(adaptableId);
+    if (!api) {
+        return;
+    }
+    postStateChangeMessage(adaptableId, { api });
+}
+function registerAdaptableInstanceInDevTools(adaptableId, options, adaptableInstance) {
+    const { api } = options;
+    // Remounts (e.g. React strict mode) reuse the same adaptableId — rebind listeners to the live API.
+    detachAdaptableInstanceListeners(adaptableId);
+    console.log(`Registering instance "${adaptableId}" into Adaptable DevTools`);
+    REGISTERED_ADAPTABLE_IDS.add(adaptableId);
+    REGISTERED_ADAPTABLE_APIS.set(adaptableId, api);
+    if (adaptableInstance) {
+        REGISTERED_ADAPTABLE_INSTANCES.set(adaptableId, adaptableInstance);
+    }
+    const onStateChange = (info) => {
+        postStateChangeMessage(adaptableId, { actionName: info.actionName, api });
+    };
+    const onStateReloaded = () => {
+        postStateChangeMessage(adaptableId, {
+            actionName: 'AdaptableStateReloaded',
+            api,
+        });
+    };
+    const unsubscribeStateChanged = api.eventApi.on('AdaptableStateChanged', onStateChange);
+    const unsubscribeStateReloaded = api.eventApi.on('AdaptableStateReloaded', onStateReloaded);
+    const unsubscribeRowSelectionChanged = api.eventApi.on('RowSelectionChanged', () => {
+        postGridRuntimeUpdate(adaptableId, api);
+    });
+    const unsubscribeDestroy = api.eventApi.on('AdaptableDestroy', () => {
+        unregisterAdaptableInstanceFromDevTools(adaptableId);
+    });
+    const adaptableGrid = adaptableInstance ?? REGISTERED_ADAPTABLE_INSTANCES.get(adaptableId);
+    const unsubscribeFiltersApplied = adaptableGrid?._on('AdapTableFiltersApplied', () => {
+        cancelScheduledGridRuntimeUpdate(adaptableId);
+        postGridRuntimeUpdate(adaptableId, api);
+    });
+    INSTANCE_REGISTRATIONS.set(adaptableId, {
+        api,
+        unsubscribe: () => {
+            unsubscribeStateChanged();
+            unsubscribeStateReloaded();
+            unsubscribeRowSelectionChanged();
+            unsubscribeFiltersApplied?.();
+            unsubscribeDestroy();
+        },
+    });
+    postMountMessage(adaptableId, api);
+    publishStateSnapshot(adaptableId);
+}

package/src/types.d.ts

@@ -14,7 +14,7 @@ export type { ContainerOptions, AdaptableContainerValue, AdaptableCSSSelector, I
 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';
-export type { DashboardOptions, CustomToolbar, DashboardButtonContext, CustomToolbarButtonContext, DashboardButtonsLocation, ToolbarActions, ToolbarAction, } from './AdaptableOptions/DashboardOptions';
+export type { DashboardOptions, CustomToolbar, DashboardButtonContext, CustomToolbarButtonContext, CustomToolbarFormContext, DashboardButtonsLocation, ToolbarActions, ToolbarAction, } from './AdaptableOptions/DashboardOptions';
 export type { EditOptions, ServerValidationResult, SmartEditCustomOperation, SmartEditOperation, SmartEditOperationContext, ServerValidationContext, CellEditableContext, CustomEditColumnValuesContext, EditColumnValueInfo, CustomEditColumnValueInfo, } from './AdaptableOptions/EditOptions';
 export type { ActionColumnContext, ActionColumn, ActionColumnButton, ActionColumnSettings, ActionColumnOptions, ActionButtonCommand, } from './AdaptableOptions/ActionColumnOptions';
 export type { SetPrimaryKeyValueContext, RowFormOptions, RowFormContext, CreateRowFormContext, EditRowFormContext, RowFormType, RowFormColumnContext, RowFormFieldContext, RowFormTitleContext, } from './AdaptableOptions/RowFormOptions';
@@ -37,9 +37,11 @@ export type { DateInputOptions } from './AdaptableOptions/DateInputOptions';
 export type { FilterOptions, ColumnFilterOptions, GridFilterOptions, IsRowFilterableContext, InFilterValueInfo, InFilterValueResult, InFilterValue, CustomInFilterValuesContext, GridFilterEditors, DefaultPredicateFilterContext, AdaptableFilterComponentLocation, } from './AdaptableOptions/FilterOptions';
 export type { QuickSearchOptions, QuickSearchContext } from './AdaptableOptions/QuickSearchOptions';
 export type { FormatColumnOptions, CustomDisplayFormatter, CustomDisplayFormatterContext, } from './AdaptableOptions/FormatColumnOptions';
+export type { PlusMinusOptions } from './AdaptableOptions/EditOptions';
+export type { SmartEditOptions } from './AdaptableOptions/EditOptions';
 export type { ColumnOptions, ColumnFriendlyNameContext, ColumnTypesContext, BaseColumnHeaderContext, ColumnHeaderContext, AutoGroupColumnHeaderContext, RowGroupColumnHeaderContext, TableColumnHeaderContext, TableColumnGroupHeaderContext, PivotColumnGroupHeaderContext, PivotResultColumnHeaderContext, PivotGrandTotalHeaderContext, PivotColumnTotalHeaderContext, PivotAggregationTotalHeaderContext, } from './AdaptableOptions/ColumnOptions';
 export type { AdaptablePersistStateFunction, AdaptableStateFunctionConfig, AdaptableLoadStateFunction, AdaptableSaveStateFunction, AdaptableClearStateFunction, StateOptions, } from './AdaptableOptions/StateOptions';
-export type { TableAggregationColumns, PivotAggregationColumns, WeightedAverageAggregation, } from './AdaptableState/Common/AggregationColumns';
+export type { TableAggregationColumns, PivotAggregationColumns, WeightedAverageAggregation, ParameterizedAggFunc, } from './AdaptableState/Common/AggregationColumns';
 export type { AccessLevel, Entitlement } from './AdaptableState/Common/Entitlement';
 export type { ExtendedLayout, LayoutExtension, LayoutExtensionObject, LayoutExtensionModule, LayoutExtendedConfig, } from './AdaptableState/Common/ExtendedLayout';
 export type { FilterActionOnDataChange, ApplyFilterAction, } from './AdaptableState/Common/FilterActionOnDataChange';
@@ -94,7 +96,6 @@ export type { PlusMinusApi } from './Api/PlusMinusApi';
 export type { PredicateApi } from './Api/PredicateApi';
 export type { QuickSearchApi } from './Api/QuickSearchApi';
 export type { RowFormApi } from './Api/RowFormApi';
-export type { ScheduleApi } from './Api/ScheduleApi';
 export type { ColumnScopeApi } from './Api/ColumnScopeApi';
 export type { SettingsPanelApi } from './Api/SettingsPanelApi';
 export type { ShortcutApi } from './Api/ShortcutApi';
@@ -136,13 +137,13 @@ export type { RowSelectionChangedInfo } from './Api/Events/RowSelectionChanged';
 export type { AdaptableStateReloadedInfo } from './Api/Events/AdaptableStateReloaded';
 export type { ThemeChangedInfo } from './Api/Events/ThemeChanged';
 export type { DashboardChangedInfo } from './Api/Events/DashboardChanged';
-export type { ScheduleTriggeredInfo } from './Api/Events/ScheduleTriggered';
+export type { ReportScheduleRanInfo } from './Api/Events/ReportScheduleRan';
 export type { AdaptableStateChangedInfo } from './Api/Events/AdaptableStateChanged';
 export type { BeforeAdaptableStateChangeInfo } from './Api/Events/BeforeAdaptableStateChange';
 export type { CommentChangedInfo } from './Api/Events/CommentChanged';
 export type { Fdc3MessageInfo, Fdc3MessageSentInfo, Fdc3MessageReceivedInfo, } from './Api/Events/Fdc3MessageInfo';
 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 { AlertDefinition, AlertDefinitionBase, RuleBasedAlertDefinition, ScheduledAlertDefinition, AlertPresentationProperties, RuleAlertProperties, ScheduledAlertProperties, 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';
 export type { CalculatedColumn, CalculatedColumnSettings, CalculatedColumnState, AdaptableCalculatedColumnQuery, } from './AdaptableState/CalculatedColumnState';
@@ -164,7 +165,7 @@ export type { AdaptableQuery, AdaptableAggregatedBooleanQuery, AdaptableAggregat
 export type { AdaptablePredicate, AdaptableColumnPredicate, AdaptablePredicateDef, PredicateModuleScope, PredicateDefHandlerContext, PredicateDefInput, PredicateDefToStringParams, ColumnFilterDef, } from './AdaptableState/Common/AdaptablePredicate';
 export type { ColumnScope } from './AdaptableState/Common/ColumnScope';
 export type { RowScope } from './AdaptableState/Common/RowScope';
-export type { AdaptableStyle } from './AdaptableState/Common/AdaptableStyle';
+export type { CellBoxStyle, CellFontStyle, AdaptableStyle, } from './AdaptableState/Common/AdaptableStyle';
 export type { AdaptableBaseIcon, AdaptableIcon, AdaptableSystemIcon, AdaptableCustomIcon, AdaptableSystemIconName, AdaptableElementIcon, } from './AdaptableState/Common/AdaptableIcon';
 export type { CellHighlightInfo } from './AdaptableState/Common/CellHighlightInfo';
 export type { RowHighlightInfo } from './AdaptableState/Common/RowHighlightInfo';
@@ -175,7 +176,8 @@ export type { RowDataChangedInfo, RowDataChangeTrigger, } from './AdaptableState
 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 { AdaptableFormData, AdaptableForm, AdaptableFormField, AdaptableFormFieldGroup, AdaptableFormFieldType, AdaptableFormFieldOption, AdaptableFormFieldRenderParams, AdaptableFormErrors, AdaptableFormLayout, } from './AdaptableState/Common/AdaptableForm';
+export { flattenAdaptableFormFields, getDefaultAdaptableFormData, isAdaptableFormFieldGroup, validateAdaptableForm, } 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';
@@ -192,18 +194,17 @@ export type { ExportState, Report, ReportData, ReportColumn, ReportSchedule, Sys
 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, 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 { StyledColumn, StyledColumnState, PercentBarStyle, GradientStyle, GradientZeroCentredColors, CellColorRange, DynamicRangeEndpoint, ColumnComparison, CellTextOptions, CellTextOption, NumericStyledColumn, RangeValueType, SparklineStyle, BadgeStyle, BadgeStyleDefinition, BadgeStylePredicate, BadgeShape, BadgeDensity, BadgeOverflowMode, BadgePillStyle, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, BulletChartStyle, BulletChartTarget, BulletChartTargetDefinition, BulletChartTargetMarker, RatingStyle, RatingIconShape, RangeBarStyle, RangeBarBound, RangeBarMarker, IconStyle, IconStyleMapping, IconStyleSpec, IconStyleMatchMode, IconStyleFallback, IconStyleBuiltInPreset, } from './AdaptableState/StyledColumnState';
 export type { FreeTextColumn, FreeTextColumnState, FreeTextStoredValue, FreeTextColumnSettings, } from './AdaptableState/FreeTextColumnState';
 export type { StatusBarState, AdaptableStatusBar } from './AdaptableState/StatusBarState';
-export type { IPushPullDomain, IPushPullReport, IPushPullSchedule, IPushPullState, } from './AdaptableState/IPushPullState';
-export type { Layout, LayoutState, LayoutArray, LayoutBase, TableLayout, PivotLayout, RowGroupValues, ColumnGroupValues, RowGroupValuesWithExceptionKeys, GroupKeys, ColumnGroupValuesWithExceptionKeys, ColumnStringMap, ColumnNumberMap, ColumnBooleanFalseMap, ColumnDirectionMap, ColumnSizingMap, ColumnSizingDefinition, PivotTotalPosition, LayoutRowSelection, } from './AdaptableState/LayoutState';
+export type { IPushPullDomain, IPushPullReport, IPushPullState, } from './AdaptableState/IPushPullState';
+export type { Layout, LayoutState, LayoutArray, LayoutBase, TableLayout, PivotLayout, RowGroupValues, ColumnGroupValues, RowGroupValuesWithExceptionKeys, GroupKeys, ColumnGroupValuesWithExceptionKeys, ColumnStringMap, ColumnNumberMap, ColumnBooleanFalseMap, ColumnDirectionMap, ColumnSizingMap, ColumnSizingDefinition, PivotTotalPosition, LayoutRowSelection, LayoutOpenChart, } from './AdaptableState/LayoutState';
 export type { RowSummary, RowSummaryPosition } from './AdaptableState/Common/RowSummary';
-export type { OpenFinReport, OpenFinSchedule, OpenFinState } from './AdaptableState/OpenFinState';
+export type { OpenFinReport, OpenFinState } from './AdaptableState/OpenFinState';
 export type { PlusMinusNudge, PlusMinusState } from './AdaptableState/PlusMinusState';
 export type { InitialState } from './AdaptableState/InitialState';
 export type { NamedQuery, NamedQueryState } from './AdaptableState/NamedQueryState';
 export type { QuickSearchState } from './AdaptableState/QuickSearchState';
-export type { ReminderSchedule, ScheduleState } from './AdaptableState/ScheduleState';
 export type { GridCell, GridCellWithCount, UniqueGridCell, CellUpdateRequest, CellAddress, } from './AdaptableState/Selection/GridCell';
 export type { GridRow, RowInfo } from './AdaptableState/Selection/GridRow';
 export type { SelectedCellInfo } from './AdaptableState/Selection/SelectedCellInfo';

package/src/types.js

@@ -2,3 +2,4 @@
 // Expressions
 export { AdaptablePlugin } from './AdaptableOptions/AdaptablePlugin';
 export { NUMERIC_FORMAT_PRESETS, isAdaptableNumericFormatPreset, resolveDisplayFormat, } from './AdaptableState/Common/AdaptableFormatPresets';
+export { flattenAdaptableFormFields, getDefaultAdaptableFormData, isAdaptableFormFieldGroup, validateAdaptableForm, } from './AdaptableState/Common/AdaptableForm';

package/themes/dark.css

@@ -1,10 +1,21 @@
 @layer adaptable.theme {
   .ab--theme-dark {
+    /****** Shadcn colors ******/
+    --ab-color-background: oklch(0.145 0 0);
+    --ab-color-foreground: oklch(0.985 0 0);
+    --ab-color-secondary: oklch(0.269 0 0);
+    --ab-color-secondary-foreground: oklch(0.985 0 0);
+    --ab-color-destructive: oklch(0.396 0.141 25.723);
+    --ab-color-destructive-foreground: oklch(0.637 0.237 25.331);
+    --ab-color-border: oklch(0.269 0 0);
+    /******/
+
     --ab-theme-loaded: dark;
 
     --ab-cmp-input--disabled__background: #232323; /* #b6b7b8 */
 
     --ab-color-defaultbackground: #3e444c;
+    --ab-color-background: var(--ab-color-defaultbackground, #3e444c);
     --ab-color-text-on-defaultbackground: #e2e2e2;
 
     --ab-color-primary: #262d2f;
@@ -12,16 +23,25 @@
     --ab-color-primarydark: #1c2021;
     --ab-color-text-on-primary: #e2e2e2; /* F2F2F2 */
 
+    --ab-color-palette-1: #5c1a1a;
+    --ab-color-palette-2: #ffb4b4;
+    --ab-color-palette-3: #4a3b00;
+    --ab-color-palette-4: #ffd966;
+    --ab-color-palette-5: #1b4332;
+    --ab-color-palette-6: #95d5b2;
+    --ab-color-palette-7: #1a365d;
+    --ab-color-palette-8: #90cdf4;
+    --ab-color-palette-9: #2d3748;
+    --ab-color-palette-10: #e2e8f0;
+    --ab-color-palette-11: #44337a;
+    --ab-color-palette-12: #d6bcfa;
+
     --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-color-filtered-columns: var(--ab-color-text-on-primary);
-    --ab-color-filtered-columns-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);
   }
@@ -41,9 +61,9 @@ 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-color-input-foreground: var(--ab-color-text-on-primary);
+    --ab-cmp-input__color: var(--ab-color-input-foreground);
+    --ab-cmp-input__background: var(--ab-color-input-background);
     --ab-cmp-input--disabled__background: var(--ab-color-primarylight);
     --ab-cmp-field-wrap__background: var(--ab-color-defaultbackground);
   }