@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/Utilities/Helpers/NamedQueryHelper.d.ts

@@ -0,0 +1,24 @@
+import { NamedQuery, NamedQueryReturnType } from '../../AdaptableState/NamedQueryState';
+import type { AdaptableApi } from '../../Api/AdaptableApi';
+/**
+ * Normalizes a NamedQuery payload for add/edit entry points:
+ * - Maps leftover `BooleanExpression` / `ScalarExpression` → `Expression`
+ * - Leaves `ReturnType` optional (absent ⇒ boolean at read time)
+ */
+export declare const normalizeNamedQuery: (namedQuery: NamedQuery) => NamedQuery;
+export declare const RETURN_TYPE_OPTIONS: {
+    value: NamedQueryReturnType;
+    label: string;
+}[];
+/**
+ * Evaluates the expression against the first grid row and infers the
+ * NamedQueryReturnType from the result. Returns undefined when the expression
+ * is invalid/incomplete or the result carries no type information (null).
+ */
+export declare const suggestNamedQueryReturnTypeFromExpression: (api: AdaptableApi, expression: string) => NamedQueryReturnType | undefined;
+/**
+ * Infers a NamedQueryReturnType from a runtime evaluation result
+ * (same heuristics as Calculated Column data-type inference).
+ */
+export declare const inferNamedQueryReturnType: (value: unknown) => NamedQueryReturnType;
+export declare const runtimeMatchesNamedQueryReturnType: (value: unknown, returnType: NamedQueryReturnType) => boolean;

package/src/Utilities/Helpers/NamedQueryHelper.js

@@ -0,0 +1,77 @@
+import { NamedQueryModuleId } from '../Constants/ModuleConstants';
+export const normalizeNamedQuery = (namedQuery) => {
+    const legacy = namedQuery;
+    if (legacy.Expression == null) {
+        if (legacy.BooleanExpression != null) {
+            legacy.Expression = legacy.BooleanExpression;
+        }
+        else if (legacy.ScalarExpression != null) {
+            legacy.Expression = legacy.ScalarExpression;
+        }
+    }
+    delete legacy.BooleanExpression;
+    delete legacy.ScalarExpression;
+    return legacy;
+};
+export const RETURN_TYPE_OPTIONS = [
+    { value: 'boolean', label: 'Boolean' },
+    { value: 'number', label: 'Number' },
+    { value: 'text', label: 'Text' },
+    { value: 'date', label: 'Date' },
+    { value: 'numberArray', label: 'Number Array' },
+    { value: 'textArray', label: 'Text Array' },
+];
+export const suggestNamedQueryReturnTypeFromExpression = (api, expression) => {
+    try {
+        const previewRow = api.gridApi.getFirstRowNode();
+        const result = api.internalApi
+            .getQueryLanguageService()
+            .evaluateScalarExpression(expression, NamedQueryModuleId, previewRow);
+        if (result == null) {
+            return undefined;
+        }
+        return inferNamedQueryReturnType(result);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const inferNamedQueryReturnType = (value) => {
+    if (value instanceof Date) {
+        return 'date';
+    }
+    if (typeof value === 'boolean') {
+        return 'boolean';
+    }
+    if (typeof value === 'string') {
+        return 'text';
+    }
+    if (typeof value === 'number') {
+        return 'number';
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0 || value.every((item) => typeof item === 'number')) {
+            return 'numberArray';
+        }
+        return 'textArray';
+    }
+    return 'boolean';
+};
+export const runtimeMatchesNamedQueryReturnType = (value, returnType) => {
+    switch (returnType) {
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'number':
+            return typeof value === 'number' && !Number.isNaN(value);
+        case 'text':
+            return typeof value === 'string';
+        case 'date':
+            return value instanceof Date && !Number.isNaN(value.getTime());
+        case 'numberArray':
+            return Array.isArray(value) && value.every((item) => typeof item === 'number');
+        case 'textArray':
+            return Array.isArray(value) && value.every((item) => typeof item === 'string');
+        default:
+            return false;
+    }
+};

package/src/Utilities/Helpers/NotesHelper.d.ts

@@ -0,0 +1,11 @@
+import { NotesDataSource } from 'ag-grid-enterprise';
+import { AdaptableApi } from '../../types';
+/**
+ * Bridges AG Grid's native Cell Notes (`notesDataSource`) onto AdapTable's Note State.
+ *
+ * AG Grid owns rendering / editing / hover / keyboard / context-menu, while AdapTable's
+ * `NoteState` remains the source of truth - so Notes are still persisted, team-shared and
+ * visible in the "Notes" view. `getNote` reads from State; `setNote` dispatches the existing
+ * Note redux actions (add / edit / delete) and auto-stamps author + timestamps.
+ */
+export declare const createAdaptableNotesDataSource: (api: AdaptableApi) => NotesDataSource;

package/src/Utilities/Helpers/NotesHelper.js

@@ -0,0 +1,71 @@
+import FormatHelper from './DisplayFormatHelper';
+export const createAdaptableNotesDataSource = (api) => {
+    const formatTimestamp = (timestamp) => {
+        if (timestamp == null) {
+            return undefined;
+        }
+        return FormatHelper.DateFormatter(timestamp, {
+            Pattern: api.noteApi.internalApi.getNotesDateFormat(),
+        });
+    };
+    const toAgGridNote = (note) => {
+        if (!note) {
+            return undefined;
+        }
+        const isReadOnly = !!note.IsReadOnly || api.entitlementApi.isModuleReadOnlyEntitlement('Note');
+        return {
+            text: note.Text ?? '',
+            readOnly: isReadOnly || undefined,
+            author: note.Author,
+            createdAt: formatTimestamp(note.CreatedAt),
+            updatedAt: formatTimestamp(note.UpdatedAt),
+            metadata: note.Metadata,
+        };
+    };
+    const getPrimaryKeyValue = (params) => api.gridApi.getPrimaryKeyValueForRowNode(params.rowNode);
+    return {
+        getNote: (params) => {
+            const primaryKeyValue = getPrimaryKeyValue(params);
+            if (primaryKeyValue == null) {
+                return undefined;
+            }
+            const note = api.noteApi.getNoteForCell({
+                PrimaryKeyValue: primaryKeyValue,
+                ColumnId: params.column.getColId(),
+            });
+            return toAgGridNote(note);
+        },
+        setNote: (params) => {
+            const primaryKeyValue = getPrimaryKeyValue(params);
+            if (primaryKeyValue == null) {
+                return;
+            }
+            const columnId = params.column.getColId();
+            const existingNote = api.noteApi.getNoteForCell({
+                PrimaryKeyValue: primaryKeyValue,
+                ColumnId: columnId,
+            });
+            if (params.note === undefined) {
+                if (existingNote) {
+                    api.noteApi.deleteNote(existingNote);
+                }
+                return;
+            }
+            if (existingNote) {
+                api.noteApi.editNote({
+                    ...existingNote,
+                    Text: params.note.text ?? '',
+                    Author: params.note.author ?? existingNote.Author,
+                    Metadata: params.note.metadata ?? existingNote.Metadata,
+                    IsReadOnly: params.note.readOnly ?? existingNote.IsReadOnly,
+                });
+                return;
+            }
+            api.noteApi.addNote(params.note.text ?? '', primaryKeyValue, columnId, {
+                Author: params.note.author,
+                Metadata: params.note.metadata,
+                IsReadOnly: params.note.readOnly,
+            });
+        },
+    };
+};

package/src/Utilities/Helpers/Scheduling/ScheduleHelper.d.ts

@@ -19,4 +19,3 @@ export declare function parseOneOffDateFromRunAt(runAt?: string): string;
 export declare function getNextRunDateFromSchedule(schedule: Schedule): Date | null;
 export declare function isScheduleValid(schedule: Schedule): true | string;
 export declare function getScheduleDescription(schedule: Schedule): string;
-export declare function isValidCronExpression(expression: string): boolean;

package/src/Utilities/Helpers/Scheduling/ScheduleHelper.js

@@ -1,4 +1,3 @@
-import StringExtensions from '../../Extensions/StringExtensions';
 import { getNextCronOccurrence, isCronExpressionValid as isCronExpressionValidInternal, } from './CronExpression';
 const WEEKDAY_TO_CRON = {
     Sunday: 0,
@@ -217,9 +216,3 @@ function clampHour(h) {
 function clampMinute(m) {
     return Math.min(59, Math.max(0, m));
 }
-export function isValidCronExpression(expression) {
-    if (StringExtensions.IsNullOrEmpty(expression)) {
-        return false;
-    }
-    return isCronExpressionValidInternal(expression.trim());
-}

package/src/Utilities/Helpers/Scheduling/ScheduledAlertHelper.d.ts

@@ -1,6 +1,11 @@
-import { AlertButtonForm, AlertDefinition, RuleAlertProperties, RuleBasedAlertDefinition, ScheduledAlertDefinition } from '../../../AdaptableState/AlertState';
+import { AlertButtonForm, AlertDefinition, GridAlertDefinition, RuleAlertProperties, ScheduledAlertDefinition } from '../../../AdaptableState/AlertState';
 export declare function isScheduledAlertDefinition(alert: AlertDefinition | undefined | null): alert is ScheduledAlertDefinition;
-export declare function isRuleBasedAlertDefinition(alert: AlertDefinition | undefined | null): alert is RuleBasedAlertDefinition;
+/**
+ * Every grid-evaluated Alert: a Rule-carrying definition or a Row Change one
+ * (whose per-row `Rule` is optional). Complement of
+ * {@link isScheduledAlertDefinition}.
+ */
+export declare function isRuleBasedAlertDefinition(alert: AlertDefinition | undefined | null): alert is GridAlertDefinition;
 export declare function getRuleAlertProperties(alert: AlertDefinition | undefined | null): RuleAlertProperties | undefined;
 export declare function getActiveScheduledAlertDefinitions(alerts: AlertDefinition[]): ScheduledAlertDefinition[];
 export declare function getScheduledAlertNotificationForm(includeSuspendButton: boolean): AlertButtonForm;

package/src/Utilities/Helpers/Scheduling/ScheduledAlertHelper.js

@@ -1,3 +1,4 @@
+import { isRowChangeAlertDefinition, } from '../../../AdaptableState/AlertState';
 import ObjectFactory from '../../ObjectFactory';
 import { EMPTY_STRING } from '../../Constants/GeneralConstants';
 import { ALERT_DEFAULT_MESSAGE_TYPE } from '../../Constants/ObjectDefaultConstants';
@@ -6,7 +7,7 @@ export function isScheduledAlertDefinition(alert) {
     return alert != null && 'Schedule' in alert;
 }
 export function isRuleBasedAlertDefinition(alert) {
-    return alert != null && 'Rule' in alert;
+    return alert != null && ('Rule' in alert || isRowChangeAlertDefinition(alert));
 }
 export function getRuleAlertProperties(alert) {
     return isRuleBasedAlertDefinition(alert) ? alert.AlertProperties : undefined;
@@ -38,6 +39,7 @@ export function CreateEmptyScheduledAlertDefinition(name) {
     return {
         Uuid: createUuid(),
         Name: displayName || EMPTY_STRING,
+        Type: 'Scheduled',
         MessageType: ALERT_DEFAULT_MESSAGE_TYPE,
         Schedule: ObjectFactory.CreateDefaultSchedule(),
         MessageHeader: displayName,

package/src/Utilities/Helpers/Scheduling/ScheduledReportHelper.d.ts

@@ -1,9 +1,4 @@
-import { ExportState, ReportNameType, ReportSchedule } from '../../../AdaptableState/ExportState';
-export declare function reportScheduleToSchedule(reportSchedule: {
-    ReportName?: string;
-    ScheduleType?: string;
-} & Omit<ReportSchedule, 'ReportName'> & Partial<Pick<ReportSchedule, 'ReportName'>>): ReportSchedule;
-export declare function withReportName(schedule: ReportSchedule, reportName: ReportNameType): ReportSchedule;
+import { ExportState, ReportSchedule } from '../../../AdaptableState/ExportState';
 export declare function normalizeScheduledReportSchedule(schedule: ReportSchedule): ReportSchedule;
 export declare function getScheduledReports(exportState: ExportState): ReportSchedule[];
 export declare function exportStateNeedsScheduleUuids(exportState: ExportState): boolean;
@@ -13,4 +8,3 @@ export declare function exportStateNeedsScheduleUuids(exportState: ExportState):
  */
 export declare function ensureExportStateSchedulesUuids(exportState: ExportState): ExportState;
 export declare function replaceScheduledReportScheduleInList(schedules: ReportSchedule[], schedule: ReportSchedule): ReportSchedule[];
-export declare function countSchedulesForReport(exportState: ExportState, reportName: ReportNameType): number;

package/src/Utilities/Helpers/Scheduling/ScheduledReportHelper.js

@@ -1,14 +1,4 @@
 import { createUuid } from '../../../AdaptableState/Uuid';
-export function reportScheduleToSchedule(reportSchedule) {
-    const { ReportName: reportName, ScheduleType: _scheduleType, ...schedule } = reportSchedule;
-    return {
-        ...schedule,
-        ReportName: reportSchedule.ReportName ?? reportName ?? '',
-    };
-}
-export function withReportName(schedule, reportName) {
-    return { ...schedule, ReportName: reportName };
-}
 export function normalizeScheduledReportSchedule(schedule) {
     return schedule;
 }
@@ -39,7 +29,3 @@ export function replaceScheduledReportScheduleInList(schedules, schedule) {
     next[index] = schedule;
     return next;
 }
-export function countSchedulesForReport(exportState, reportName) {
-    return getScheduledReports(exportState).filter((s) => s.ReportName === reportName)
-        .length;
-}

package/src/Utilities/Helpers/SettingsPanelHelper.d.ts

@@ -1,5 +1,43 @@
 import { AdaptableApi } from '../../Api/AdaptableApi';
-import { SettingsPanelNavigation, SettingsPanelNavigationGroup, SettingsPanelOptions } from '../../AdaptableOptions/SettingsPanelOptions';
+import { SettingsPanelDisplayOptions, SettingsPanelNavigation, SettingsPanelNavigationGroup, SettingsPanelOptions } from '../../AdaptableOptions/SettingsPanelOptions';
+import { AdaptableIcon } from '../../types';
+/**
+ * True when `adaptableId` is the framework placeholder (`adaptable_id` or `adaptable_id_<n>`),
+ * not a developer-supplied human name.
+ */
+export declare const isGenericAdaptableId: (adaptableId?: string) => boolean;
+export type ResolvedSettingsPanelDisplayOptions = Required<SettingsPanelDisplayOptions>;
+/**
+ * Resolves Settings Panel navigation display flags.
+ * Prefers `displayOptions`, then deprecated top-level props, then `true`.
+ */
+export declare const resolveSettingsPanelDisplayOptions: (settingsPanelOptions?: SettingsPanelOptions) => ResolvedSettingsPanelDisplayOptions;
+/**
+ * Resolves the Settings Panel chrome title:
+ * 1. Explicit `settingsPanelOptions.title` when provided
+ * 2. Else `adaptableId` when it is a meaningful (non-generic) value
+ * 3. Else `'Grid Settings'`
+ */
+export declare const resolveSettingsPanelTitle: (adaptableId?: string, explicitTitle?: string) => string;
+/**
+ * Runtime user-facing label for controls that open a module page in the panel.
+ * Uses the resolved chrome title (never the internal name “Settings Panel”).
+ *
+ * e.g. `Open Alerts in Grid Settings` / `Open Notes in Trade Blotter`
+ */
+export declare const getOpenModuleInPanelLabel: (moduleLabel: string, panelTitle: string) => string;
+/**
+ * Resolves the Settings Panel chrome icon:
+ * 1. Explicit `settingsPanelOptions.icon` when provided
+ * 2. Else `'ApplicationIcon'` when `userInterfaceOptions.applicationIcon` is set
+ * 3. Else `'ConfigurationIcon'`
+ */
+export declare const resolveSettingsPanelIcon: (applicationIcon?: AdaptableIcon, explicitIcon?: SettingsPanelOptions["icon"]) => NonNullable<SettingsPanelOptions["icon"]>;
+/**
+ * Resolves the concrete icon used to open the Settings Panel (Dashboard Home control, Tool Panel
+ * Settings button, etc.) from the already-resolved `settingsPanelOptions.icon` value.
+ */
+export declare const getSettingsPanelOpenIcon: (resolvedIcon: SettingsPanelOptions["icon"], applicationIcon?: AdaptableIcon) => AdaptableIcon;
 export declare const DEFAULT_SETTINGS_PANEL_NAVIGATION_GROUPS: SettingsPanelNavigationGroup[];
 export declare const buildDefaultSettingsPanelNavigation: (customPanelNames?: string[]) => SettingsPanelNavigation;
 export declare const resolveSettingsPanelNavigation: (api: AdaptableApi, settingsPanelOptions: SettingsPanelOptions) => SettingsPanelNavigation;

package/src/Utilities/Helpers/SettingsPanelHelper.js

@@ -1,3 +1,51 @@
+import { ADAPTABLE_ID } from '../Constants/GeneralConstants';
+import { SettingsPanelFriendlyName } from '../Constants/ModuleConstants';
+import StringExtensions from '../Extensions/StringExtensions';
+export const isGenericAdaptableId = (adaptableId) => {
+    if (StringExtensions.IsNullOrEmpty(adaptableId)) {
+        return true;
+    }
+    return adaptableId === ADAPTABLE_ID || adaptableId.startsWith(`${ADAPTABLE_ID}_`);
+};
+export const resolveSettingsPanelDisplayOptions = (settingsPanelOptions) => {
+    const displayOptions = settingsPanelOptions?.displayOptions;
+    return {
+        showModuleIcons: displayOptions?.showModuleIcons ?? settingsPanelOptions?.showModuleIcons ?? true,
+        showModuleDescriptions: displayOptions?.showModuleDescriptions ??
+            settingsPanelOptions?.showModuleDescriptions ??
+            true,
+        showNavigationSearch: displayOptions?.showNavigationSearch ?? true,
+        enableCollapseView: displayOptions?.enableCollapseView ?? true,
+    };
+};
+export const resolveSettingsPanelTitle = (adaptableId, explicitTitle) => {
+    if (StringExtensions.IsNotNullOrEmpty(explicitTitle)) {
+        return explicitTitle;
+    }
+    if (!isGenericAdaptableId(adaptableId)) {
+        return adaptableId;
+    }
+    return SettingsPanelFriendlyName;
+};
+export const getOpenModuleInPanelLabel = (moduleLabel, panelTitle) => `Open ${moduleLabel} in ${panelTitle}`;
+export const resolveSettingsPanelIcon = (applicationIcon, explicitIcon) => {
+    if (explicitIcon != null) {
+        return explicitIcon;
+    }
+    if (applicationIcon != null) {
+        return 'ApplicationIcon';
+    }
+    return 'ConfigurationIcon';
+};
+export const getSettingsPanelOpenIcon = (resolvedIcon, applicationIcon) => {
+    if (resolvedIcon === 'ApplicationIcon' && applicationIcon != null) {
+        return applicationIcon;
+    }
+    if (resolvedIcon != null && typeof resolvedIcon === 'object') {
+        return resolvedIcon;
+    }
+    return { name: 'settings' };
+};
 export const DEFAULT_SETTINGS_PANEL_NAVIGATION_GROUPS = [
     {
         label: 'Grid & UI',
@@ -5,7 +53,7 @@ export const DEFAULT_SETTINGS_PANEL_NAVIGATION_GROUPS = [
     },
     {
         label: 'Layout',
-        items: ['Layout', 'CalculatedColumn', 'FreeTextColumn', 'CustomSort', 'Charting'],
+        items: ['Layout', 'CalculatedColumn', 'FreeTextColumn', 'CustomSort', 'Charting', 'CellSummary'],
     },
     {
         label: 'Formatting',
@@ -25,7 +73,7 @@ export const DEFAULT_SETTINGS_PANEL_NAVIGATION_GROUPS = [
     },
     {
         label: 'Editing',
-        items: ['PlusMinus', 'Shortcut', 'DataChangeHistory'],
+        items: ['BulkUpdate', 'SmartEdit', 'PlusMinus', 'Shortcut', 'DataChangeHistory'],
     },
     {
         label: 'Administration',

package/src/Utilities/Helpers/StyleHelper.d.ts

@@ -18,22 +18,6 @@ export declare const hasCellFontStyle: (style: Partial<CellFontStyle> | undefine
  * Returns true when the given style has any property in the Cell (box) slice set.
  */
 export declare const hasCellBoxStyle: (style: Partial<CellBoxStyle> | undefined) => boolean;
-/**
- * Returns a copy of `style` containing only Font-slice keys.
- */
-export declare const pickCellFontStyle: (style: Partial<AdaptableStyle> | undefined) => CellFontStyle;
-/**
- * Returns a copy of `style` containing only Cell-slice (box) keys.
- */
-export declare const pickCellBoxStyle: (style: Partial<AdaptableStyle> | undefined) => CellBoxStyle;
-/**
- * Returns a copy of `style` with all Font-slice keys removed.
- */
-export declare const omitCellFontStyle: (style: AdaptableStyle | undefined) => AdaptableStyle;
-/**
- * Returns a copy of `style` with all Cell-slice (box) keys removed.
- */
-export declare const omitCellBoxStyle: (style: AdaptableStyle | undefined) => AdaptableStyle;
 export declare const AgGridCellStyleProperties: readonly ["backgroundColor", "color", "fontWeight", "fontStyle", "fontSize", "borderColor", "--ab-dynamic-background-color", "--ab-dynamic-color", "--ab-dynamic-font-weight", "--ab-dynamic-font-style", "--ab-dynamic-font-size", "--ab-dynamic-text-decoration", "--ab-dynamic-border-radius", "--ab-dynamic-border-color"];
 export declare const normalizeStyleForAgGrid: (style: Record<string, any>) => {
     [x: string]: any;

package/src/Utilities/Helpers/StyleHelper.js

@@ -21,42 +21,6 @@ const hasAtLeastOneKey = (obj, keys) => {
 };
 export const hasCellFontStyle = (style) => hasAtLeastOneKey(style, CELL_FONT_STYLE_KEYS);
 export const hasCellBoxStyle = (style) => hasAtLeastOneKey(style, CELL_BOX_STYLE_KEYS);
-export const pickCellFontStyle = (style) => {
-    const out = {};
-    if (!style) {
-        return out;
-    }
-    CELL_FONT_STYLE_KEYS.forEach((k) => {
-        const v = style[k];
-        if (v !== undefined && v !== null) {
-            out[k] = v;
-        }
-    });
-    return out;
-};
-export const pickCellBoxStyle = (style) => {
-    const out = {};
-    if (!style) {
-        return out;
-    }
-    CELL_BOX_STYLE_KEYS.forEach((k) => {
-        const v = style[k];
-        if (v !== undefined && v !== null) {
-            out[k] = v;
-        }
-    });
-    return out;
-};
-export const omitCellFontStyle = (style) => {
-    const out = { ...(style ?? {}) };
-    CELL_FONT_STYLE_KEYS.forEach((k) => delete out[k]);
-    return out;
-};
-export const omitCellBoxStyle = (style) => {
-    const out = { ...(style ?? {}) };
-    CELL_BOX_STYLE_KEYS.forEach((k) => delete out[k]);
-    return out;
-};
 export const AgGridCellStyleProperties = [
     'backgroundColor',
     'color',

package/src/Utilities/Helpers/StyledColumns/BarStylesHelper.d.ts

@@ -28,8 +28,6 @@ export declare const toggleBarStyleCellTextToken: (current: BarStyleCellTextProp
 };
 export declare const buildBarStyleCellTextLabels: (props: BarStyleCellTextProperties | undefined, cellValueLabel: string | undefined, percentageLabel: string | undefined) => BarStyleCellTextLabels;
 export declare const hasBarStyleCellTextLabels: (labels: BarStyleCellTextLabels) => boolean;
-/** Join active labels with a space, Cell Value first then Percent Value. */
-export declare const joinBarStyleCellTextLabels: (labels: BarStyleCellTextLabels) => string;
 export type BarStyleCellTextSlotEntry = {
     vertical: BarStyleCellTextVerticalAlignment;
     horizontal: BarStyleCellTextHorizontalAlignment;

package/src/Utilities/Helpers/StyledColumns/BarStylesHelper.js

@@ -100,14 +100,6 @@ export const buildBarStyleCellTextLabels = (props, cellValueLabel, percentageLab
     return labels;
 };
 export const hasBarStyleCellTextLabels = (labels) => Boolean(labels.cellValue || labels.percentage);
-export const joinBarStyleCellTextLabels = (labels) => {
-    const parts = [];
-    if (labels.cellValue)
-        parts.push(labels.cellValue);
-    if (labels.percentage)
-        parts.push(labels.percentage);
-    return parts.join(' ');
-};
 export const resolveBarStyleCellTextSlots = (props, labels) => {
     const layout = resolveBarStyleCellTextLayout(props);
     const candidates = [];

package/src/Utilities/Helpers/StyledColumns/GradientStyleHelper.d.ts

@@ -20,8 +20,6 @@ export declare const STYLED_COLUMN_PREVIEW_SAMPLE_COUNT = 6;
 /** Illustrative zero-centred scale endpoints for preview geometry. */
 export declare const ZERO_CENTRED_PREVIEW_SCALE_MIN = -20;
 export declare const ZERO_CENTRED_PREVIEW_SCALE_MAX = 20;
-/** @deprecated Use {@link getZeroCentredGradientPreviewValues} — kept for callers using endpoints. */
-export declare const ZERO_CENTRED_GRADIENT_PREVIEW_VALUES: readonly number[];
 export declare const getZeroCentredGradientPreviewValues: () => number[];
 export declare function isDivergingZeroCellRanges(ranges: CellColorRange[] | undefined): boolean;
 export declare function isZeroCentredGradientStyle(gs: GradientStyle): boolean;

package/src/Utilities/Helpers/StyledColumns/GradientStyleHelper.js

@@ -15,7 +15,6 @@ const evenlySpacedValues = (min, max, count) => {
 export const STYLED_COLUMN_PREVIEW_SAMPLE_COUNT = 6;
 export const ZERO_CENTRED_PREVIEW_SCALE_MIN = -20;
 export const ZERO_CENTRED_PREVIEW_SCALE_MAX = 20;
-export const ZERO_CENTRED_GRADIENT_PREVIEW_VALUES = evenlySpacedValues(ZERO_CENTRED_PREVIEW_SCALE_MIN, ZERO_CENTRED_PREVIEW_SCALE_MAX, STYLED_COLUMN_PREVIEW_SAMPLE_COUNT);
 export const getZeroCentredGradientPreviewValues = () => evenlySpacedValues(ZERO_CENTRED_PREVIEW_SCALE_MIN, ZERO_CENTRED_PREVIEW_SCALE_MAX, STYLED_COLUMN_PREVIEW_SAMPLE_COUNT);
 export function isDivergingZeroCellRanges(ranges) {
     if (!ranges || ranges.length !== 2) {

package/src/Utilities/Helpers/StyledColumns/PercentBarStyleHelper.d.ts

@@ -1,4 +1,3 @@
-import { StyledColumn } from '../../../AdaptableState/StyledColumnState';
 import { PercentBarStyle } from '../../../AdaptableState/StyledColumns/PercentBarStyle';
 export declare const hasPercentBarRangesConfigured: (pb: PercentBarStyle | undefined) => boolean;
 /** Illustrative scale for preview — shows negatives when origin is Auto or Zero. */
@@ -14,7 +13,5 @@ export type PercentBarPreviewGeometry = {
     barColor?: string;
 };
 export declare const getPercentBarPreviewGeometry: (numericValue: number, pb: PercentBarStyle, min: number, max: number) => PercentBarPreviewGeometry;
-export declare const formatPercentBarPreviewCellText: (numericValue: number, percentageValue: number, pb: PercentBarStyle) => string;
 export declare const getPercentBarPreviewTrackColor: (pb: PercentBarStyle) => string | undefined;
 export declare const getPercentBarPreviewResolvedBarColor: (color: string | undefined) => string | undefined;
-export declare const hasPercentBarStylePreview: (styledColumn: StyledColumn) => boolean;

package/src/Utilities/Helpers/StyledColumns/PercentBarStyleHelper.js

@@ -1,7 +1,6 @@
 import { getVariableColor } from '../StyleHelper';
 import { clamp } from '../../Extensions/NumberExtensions';
 import { STYLED_COLUMN_PREVIEW_SAMPLE_COUNT, ZERO_CENTRED_PREVIEW_SCALE_MAX, ZERO_CENTRED_PREVIEW_SCALE_MIN, } from './GradientStyleHelper';
-import { buildBarStyleCellTextLabels, joinBarStyleCellTextLabels } from './BarStylesHelper';
 const evenlySpacedValues = (min, max, count) => {
     if (count <= 1) {
         return [min];
@@ -123,10 +122,6 @@ export const getPercentBarPreviewGeometry = (numericValue, pb, min, max) => {
         barColor: getPreviewBarColor(numericValue, pb, min, max),
     };
 };
-export const formatPercentBarPreviewCellText = (numericValue, percentageValue, pb) => {
-    const labels = buildBarStyleCellTextLabels(pb.CellTextProperties, Number.isInteger(numericValue) ? String(numericValue) : numericValue.toFixed(1), `${percentageValue.toFixed(0)}%`);
-    return joinBarStyleCellTextLabels(labels);
-};
 export const getPercentBarPreviewTrackColor = (pb) => {
     if (pb.ColumnComparison) {
         return pb.BackColor ?? undefined;
@@ -134,4 +129,3 @@ export const getPercentBarPreviewTrackColor = (pb) => {
     return pb.BackColor ?? undefined;
 };
 export const getPercentBarPreviewResolvedBarColor = (color) => (color ? getVariableColor(color) : undefined);
-export const hasPercentBarStylePreview = (styledColumn) => hasPercentBarRangesConfigured(styledColumn.PercentBarStyle);

package/src/Utilities/Helpers/UIHelper.d.ts

@@ -0,0 +1,75 @@
+import { CSSProperties } from 'react';
+import { EditableConfigEntityState } from '../../View/Components/SharedProps/EditableConfigEntityState';
+import { StatusColour } from '../../AdaptableState/Common/Enums';
+import { AdaptableStyle } from '../../AdaptableState/Common/AdaptableStyle';
+import { Schedule, Weekday } from '../../AdaptableState/Common/Schedule';
+import { AdaptableColumnDataType, AdaptableSystemIconName } from '../../types';
+import { AdaptableAlert } from '../../AdaptableState/Common/AdaptableAlert';
+import { AdaptableMessageType } from '../../AdaptableState/Common/AdaptableMessageType';
+/** Generic swatch entries for the Colour Picker (resolved at runtime per active theme). */
+export declare function getSwatchColorVar(index: number): string;
+/** Default mid-gray from the theme swatch palette (`--ab-color-swatch-4`). */
+export declare function getGraySwatchColor(): string;
+export declare function getSwatchColorPaletteEntries(): string[];
+/** Theme semantic colours for the Colour Picker (resolved at runtime per active theme). */
+export declare function getThemeSemanticColorPaletteEntries(): string[];
+/** Swatch and theme semantic entries (default Colour Picker set). */
+export declare function getDefaultColorPalette(): string[];
+export declare function getEmptyConfigState(): EditableConfigEntityState;
+export declare function getDescriptionForDataType(dataType: AdaptableColumnDataType): "text" | "number" | "date";
+export declare function getPlaceholderForDataType(dataType: AdaptableColumnDataType): "Enter Value" | "Enter Number" | "Enter Date";
+export declare function IsEmptyStyle(style: AdaptableStyle): boolean;
+export declare function IsNotEmptyStyle(style: AdaptableStyle): boolean;
+export declare function getMessageTypeByStatusColour(statusColour: StatusColour): AdaptableMessageType;
+export declare function getButtonToneByMessageType(messageType: AdaptableMessageType): 'success' | 'error' | 'neutral' | 'none' | 'warning' | 'info' | 'accent';
+export declare function getGlyphByMessageType(messageType: AdaptableMessageType): AdaptableSystemIconName;
+export declare function getColorByMessageType(messageType: AdaptableMessageType): string;
+export declare function getStyleForStatusColour(statusColour: StatusColour): CSSProperties;
+export declare function getStyleForMessageType(messageType: AdaptableMessageType): CSSProperties;
+export declare function getGlyphForStatusColour(statusColour: StatusColour): string;
+export declare function getGlyphForMessageType(messageType: AdaptableMessageType): string;
+export declare function getButtonToneForMessageType(messageType: AdaptableMessageType): 'info' | 'warning' | 'error' | 'success';
+export declare function getScheduleDescription(schedule: Schedule): string;
+export declare function getWeekDayByIndex(dayOfWeek: number): Weekday;
+export declare function getMessageTypeFromAdaptableAlerts(adaptableAlerts: AdaptableAlert[]): AdaptableMessageType;
+export declare function getButtonColourForAdaptableAlerts(adaptableAlerts: AdaptableAlert[], messageTypeColor: string): string;
+export declare function getButtonTextColourForArrayandMessageType(adaptableAlerts: AdaptableAlert[], messageType: AdaptableMessageType): string;
+export declare function getButtonTextColourForMessageType(messageType: AdaptableMessageType): string;
+export declare function getAdaptableToolPanelWidth(): number;
+export declare function getSimpleButtonPaddingWidth(): number;
+export declare function getCSSVariableValue(cssVariable: string): string | undefined;
+export declare function setCSSVariableValue(cssVariable: string, value: string): void;
+export declare function isBrowserDocumentAvailable(): boolean;
+export declare const UIHelper: {
+    getSwatchColorVar: typeof getSwatchColorVar;
+    getGraySwatchColor: typeof getGraySwatchColor;
+    getSwatchColorPaletteEntries: typeof getSwatchColorPaletteEntries;
+    getThemeSemanticColorPaletteEntries: typeof getThemeSemanticColorPaletteEntries;
+    getDefaultColorPalette: typeof getDefaultColorPalette;
+    getEmptyConfigState: typeof getEmptyConfigState;
+    getDescriptionForDataType: typeof getDescriptionForDataType;
+    getPlaceholderForDataType: typeof getPlaceholderForDataType;
+    IsEmptyStyle: typeof IsEmptyStyle;
+    IsNotEmptyStyle: typeof IsNotEmptyStyle;
+    getMessageTypeByStatusColour: typeof getMessageTypeByStatusColour;
+    getGlyphByMessageType: typeof getGlyphByMessageType;
+    getButtonToneByMessageType: typeof getButtonToneByMessageType;
+    getStyleForStatusColour: typeof getStyleForStatusColour;
+    getGlyphForStatusColour: typeof getGlyphForStatusColour;
+    getButtonToneForMessageType: typeof getButtonToneForMessageType;
+    getScheduleDescription: typeof getScheduleDescription;
+    getWeekDayByIndex: typeof getWeekDayByIndex;
+    getColorByMessageType: typeof getColorByMessageType;
+    getGlyphForMessageType: typeof getGlyphForMessageType;
+    getStyleForMessageType: typeof getStyleForMessageType;
+    getMessageTypeFromAdaptableAlerts: typeof getMessageTypeFromAdaptableAlerts;
+    getButtonColourForAdaptableAlerts: typeof getButtonColourForAdaptableAlerts;
+    getButtonTextColourForArrayandMessageType: typeof getButtonTextColourForArrayandMessageType;
+    getButtonTextColourForMessageType: typeof getButtonTextColourForMessageType;
+    getCSSVariableValue: typeof getCSSVariableValue;
+    setCSSVariableValue: typeof setCSSVariableValue;
+    getAdaptableToolPanelWidth: typeof getAdaptableToolPanelWidth;
+    isBrowserDocumentAvailable: typeof isBrowserDocumentAvailable;
+    getSimpleButtonPaddingWidth: typeof getSimpleButtonPaddingWidth;
+};
+export default UIHelper;