@adaptabletools/adaptable 22.1.1-canary.1 → 23.0.0-canary.0

package/src/Utilities/Helpers/ScheduleHelper.js

@@ -0,0 +1,234 @@
+import { parseExpression } from 'cron-parser';
+import StringExtensions from '../Extensions/StringExtensions';
+const WEEKDAY_TO_CRON = {
+    Sunday: 0,
+    Monday: 1,
+    Tuesday: 2,
+    Wednesday: 3,
+    Thursday: 4,
+    Friday: 5,
+    Saturday: 6,
+};
+const CRON_WEEKDAY_NAMES = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday',
+];
+export function buildCronExpression(preset, hour, minute, options) {
+    const m = clampMinute(minute);
+    const h = clampHour(hour);
+    switch (preset) {
+        case 'daily':
+            return `${m} ${h} * * *`;
+        case 'weekdays':
+            return `${m} ${h} * * 1-5`;
+        case 'selectedDays': {
+            const days = options?.days?.length ? options.days : ['Monday'];
+            const dow = days.map((d) => WEEKDAY_TO_CRON[d]).sort((a, b) => a - b).join(',');
+            return `${m} ${h} * * ${dow}`;
+        }
+        case 'monthly': {
+            const dom = options?.dayOfMonth ?? 1;
+            return `${m} ${h} ${dom} * *`;
+        }
+        case 'custom':
+            return options?.customExpression?.trim() || `${m} ${h} * * *`;
+        default:
+            return `${m} ${h} * * *`;
+    }
+}
+export function buildRunAtIso(date, hour, minute) {
+    const d = new Date(date);
+    d.setHours(clampHour(hour), clampMinute(minute), 0, 0);
+    return d.toISOString();
+}
+export function parseTimeFromSchedule(schedule) {
+    if (schedule.IsOneOff && schedule.RunAt) {
+        const d = new Date(schedule.RunAt);
+        return { hour: d.getHours(), minute: d.getMinutes() };
+    }
+    const parts = schedule.CronExpression?.trim().split(/\s+/) ?? [];
+    if (parts.length >= 2) {
+        const minute = parseInt(parts[0], 10);
+        const hour = parseInt(parts[1], 10);
+        if (!Number.isNaN(minute) && !Number.isNaN(hour)) {
+            return { hour, minute };
+        }
+    }
+    return { hour: 9, minute: 0 };
+}
+export function inferPresetFromCron(cronExpression) {
+    const cron = cronExpression?.trim();
+    if (!cron) {
+        return { preset: 'weekdays', days: [], dayOfMonth: 1 };
+    }
+    const parts = cron.split(/\s+/);
+    if (parts.length < 5) {
+        return { preset: 'custom', days: [], dayOfMonth: 1 };
+    }
+    const [, , dom, month, dow] = parts;
+    if (dom !== '*' || month !== '*') {
+        if (dom !== '*' && month === '*') {
+            const dayOfMonth = parseInt(dom, 10);
+            return {
+                preset: 'monthly',
+                days: [],
+                dayOfMonth: Number.isNaN(dayOfMonth) ? 1 : dayOfMonth,
+            };
+        }
+        return { preset: 'custom', days: [], dayOfMonth: 1 };
+    }
+    if (dow === '*') {
+        return { preset: 'daily', days: [], dayOfMonth: 1 };
+    }
+    if (dow === '1-5') {
+        return { preset: 'weekdays', days: [], dayOfMonth: 1 };
+    }
+    const dayNumbers = dow.split(',').map((n) => parseInt(n.trim(), 10));
+    if (dayNumbers.every((n) => !Number.isNaN(n) && n >= 0 && n <= 6)) {
+        const days = dayNumbers.map((n) => CRON_WEEKDAY_NAMES[n]).filter(Boolean);
+        return { preset: 'selectedDays', days, dayOfMonth: 1 };
+    }
+    return { preset: 'custom', days: [], dayOfMonth: 1 };
+}
+export function parseOneOffDateFromRunAt(runAt) {
+    if (!runAt) {
+        return '';
+    }
+    const d = new Date(runAt);
+    if (Number.isNaN(d.getTime())) {
+        return '';
+    }
+    const y = d.getFullYear();
+    const mo = `${d.getMonth() + 1}`.padStart(2, '0');
+    const day = `${d.getDate()}`.padStart(2, '0');
+    return `${y}-${mo}-${day}`;
+}
+export function getNextRunDateFromSchedule(schedule) {
+    if (!schedule) {
+        return null;
+    }
+    try {
+        if (schedule.IsOneOff) {
+            if (!schedule.RunAt) {
+                return null;
+            }
+            const date = new Date(schedule.RunAt);
+            return date > new Date() ? date : null;
+        }
+        if (!schedule.CronExpression?.trim()) {
+            return null;
+        }
+        const interval = parseExpression(schedule.CronExpression.trim(), {
+            currentDate: new Date(),
+        });
+        const next = interval.next().toDate();
+        return next > new Date() ? next : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isScheduleValid(schedule) {
+    if (!schedule) {
+        return 'Schedule is not specified';
+    }
+    if (schedule.IsOneOff) {
+        if (!schedule.RunAt) {
+            return 'A date and time is required for a one-off schedule';
+        }
+        const date = new Date(schedule.RunAt);
+        if (Number.isNaN(date.getTime())) {
+            return 'One-off date is not valid';
+        }
+        return true;
+    }
+    if (!schedule.CronExpression?.trim()) {
+        return 'A recurring schedule is required';
+    }
+    const { preset, days } = inferPresetFromCron(schedule.CronExpression);
+    if (preset === 'selectedDays' && days.length === 0) {
+        return 'Select at least one day';
+    }
+    try {
+        parseExpression(schedule.CronExpression.trim());
+        return true;
+    }
+    catch {
+        return 'Cron expression is not valid';
+    }
+}
+export function getScheduleDescription(schedule) {
+    if (!schedule) {
+        return '[No Schedule]';
+    }
+    if (schedule.IsOneOff) {
+        if (!schedule.RunAt) {
+            return 'One-off (not set)';
+        }
+        const d = new Date(schedule.RunAt);
+        return `Once on ${d.toLocaleDateString()} @ ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+    }
+    const { preset, days, dayOfMonth } = inferPresetFromCron(schedule.CronExpression);
+    const { hour, minute } = parseTimeFromSchedule(schedule);
+    const time = `@ ${pad2(hour)}:${pad2(minute)}`;
+    switch (preset) {
+        case 'daily':
+            return `Every Day ${time}`;
+        case 'weekdays':
+            return `Weekdays ${time}`;
+        case 'selectedDays': {
+            const names = days.map((d) => getShortDay(d)).join(', ');
+            return `${names || 'Selected Days'} ${time}`;
+        }
+        case 'monthly':
+            return `Monthly on day ${dayOfMonth} ${time}`;
+        default:
+            return `${schedule.CronExpression ?? 'Custom'} ${time}`;
+    }
+}
+function getShortDay(day) {
+    switch (day) {
+        case 'Sunday':
+            return 'Sun';
+        case 'Monday':
+            return 'Mon';
+        case 'Tuesday':
+            return 'Tues';
+        case 'Wednesday':
+            return 'Weds';
+        case 'Thursday':
+            return 'Thurs';
+        case 'Friday':
+            return 'Fri';
+        case 'Saturday':
+            return 'Sat';
+        default:
+            return day;
+    }
+}
+function pad2(n) {
+    return `${n}`.padStart(2, '0');
+}
+function clampHour(h) {
+    return Math.min(23, Math.max(0, h));
+}
+function clampMinute(m) {
+    return Math.min(59, Math.max(0, m));
+}
+export function isValidCronExpression(expression) {
+    if (StringExtensions.IsNullOrEmpty(expression)) {
+        return false;
+    }
+    try {
+        parseExpression(expression.trim());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Schedule } from '../../AdaptableState/Common/Schedule';
+export interface ScheduleJobManagerConfig<T> {
+    getActiveItems: () => T[];
+    getSchedule: (item: T) => Schedule | undefined;
+    onFire: (item: T) => void;
+}
+export interface ScheduleJobManager {
+    setUpJobs(): void;
+    clearJobs(): void;
+}
+export declare function createScheduleJobManager<T>(config: ScheduleJobManagerConfig<T>): ScheduleJobManager;

package/src/Utilities/Helpers/ScheduleJobManager.js

@@ -0,0 +1,25 @@
+import { ScheduleJobRunner } from './ScheduleJobRunner';
+export function createScheduleJobManager(config) {
+    let jobs = [];
+    const clearJobs = () => {
+        jobs.forEach((j) => j?.cancel());
+        jobs = [];
+    };
+    const setUpJobs = () => {
+        clearJobs();
+        config.getActiveItems().forEach((item) => {
+            const schedule = config.getSchedule(item);
+            if (schedule == null) {
+                return;
+            }
+            const date = ScheduleJobRunner.getNextRunDate(schedule);
+            if (date != null) {
+                jobs.push(ScheduleJobRunner.scheduleJob(date, () => {
+                    config.onFire(item);
+                    setUpJobs();
+                }));
+            }
+        });
+    };
+    return { setUpJobs, clearJobs };
+}

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

@@ -0,0 +1,8 @@
+import { Schedule } from '../../AdaptableState/Common/Schedule';
+export interface ScheduleJob {
+    cancel: () => void;
+}
+export declare const ScheduleJobRunner: {
+    scheduleJob(date: Date, fn: () => void, onFire?: () => void): ScheduleJob;
+    getNextRunDate(schedule: Schedule): Date | null;
+};

package/src/Utilities/Helpers/ScheduleJobRunner.js

@@ -0,0 +1,27 @@
+import { getNextRunDateFromSchedule } from './ScheduleHelper';
+const dateTimeouts = {};
+export const ScheduleJobRunner = {
+    scheduleJob(date, fn, onFire) {
+        const timestamp = +date;
+        const now = Date.now();
+        const timeUntilDate = timestamp - now;
+        if (timeUntilDate > 0) {
+            const timeoutId = +setTimeout(() => {
+                fn();
+                onFire?.();
+            }, timeUntilDate);
+            dateTimeouts[timestamp] = timeoutId;
+        }
+        return {
+            cancel: () => {
+                const theTimeout = dateTimeouts[timestamp];
+                if (theTimeout != undefined) {
+                    clearTimeout(theTimeout);
+                }
+            },
+        };
+    },
+    getNextRunDate(schedule) {
+        return getNextRunDateFromSchedule(schedule);
+    },
+};

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

@@ -0,0 +1,8 @@
+import { AlertButtonForm, AlertDefinition, RuleAlertProperties, RuleBasedAlertDefinition, 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;
+export declare function getRuleAlertProperties(alert: AlertDefinition | undefined | null): RuleAlertProperties | undefined;
+export declare function getActiveScheduledAlertDefinitions(alerts: AlertDefinition[]): ScheduledAlertDefinition[];
+export declare function getScheduledAlertNotificationForm(includeSuspendButton: boolean): AlertButtonForm;
+export declare function scheduledAlertIncludeSuspendButton(alert: ScheduledAlertDefinition): boolean;
+export declare function CreateEmptyScheduledAlertDefinition(name?: string): ScheduledAlertDefinition;

package/src/Utilities/Helpers/ScheduledAlertHelper.js

@@ -0,0 +1,50 @@
+import ObjectFactory from '../ObjectFactory';
+import { EMPTY_STRING } from '../Constants/GeneralConstants';
+import { ALERT_DEFAULT_MESSAGE_TYPE } from '../Constants/ObjectDefaultConstants';
+import { createUuid } from '../../AdaptableState/Uuid';
+export function isScheduledAlertDefinition(alert) {
+    return alert != null && 'Schedule' in alert;
+}
+export function isRuleBasedAlertDefinition(alert) {
+    return alert != null && 'Rule' in alert;
+}
+export function getRuleAlertProperties(alert) {
+    return isRuleBasedAlertDefinition(alert) ? alert.AlertProperties : undefined;
+}
+export function getActiveScheduledAlertDefinitions(alerts) {
+    return alerts.filter((a) => !a.IsSuspended && isScheduledAlertDefinition(a));
+}
+export function getScheduledAlertNotificationForm(includeSuspendButton) {
+    const buttons = [
+        {
+            Label: 'OK',
+            ButtonStyle: { variant: 'raised' },
+        },
+    ];
+    if (includeSuspendButton) {
+        buttons.push({
+            Label: 'Suspend',
+            ButtonStyle: { variant: 'outlined' },
+            Command: 'suspend',
+        });
+    }
+    return { fields: [], Buttons: buttons };
+}
+export function scheduledAlertIncludeSuspendButton(alert) {
+    return alert.AlertProperties?.IncludeSuspendButton ?? false;
+}
+export function CreateEmptyScheduledAlertDefinition(name) {
+    const displayName = name?.trim() || '';
+    return {
+        Uuid: createUuid(),
+        Name: displayName || EMPTY_STRING,
+        MessageType: ALERT_DEFAULT_MESSAGE_TYPE,
+        Schedule: ObjectFactory.CreateDefaultSchedule(),
+        MessageHeader: displayName,
+        MessageText: displayName ? `Reminder: ${displayName}` : '',
+        AlertProperties: {
+            DisplayNotification: true,
+            DisplaySystemStatusMessage: false,
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
+export declare function refreshScheduledAlertJobs(adaptable: IAdaptable): void;
+export declare function refreshScheduledReportJobs(adaptable: IAdaptable): void;

package/src/Utilities/Helpers/ScheduledJobsMiddlewareHelper.js

@@ -0,0 +1,9 @@
+import * as ModuleConstants from '../Constants/ModuleConstants';
+export function refreshScheduledAlertJobs(adaptable) {
+    const alertModule = adaptable.adaptableModules.get(ModuleConstants.AlertModuleId);
+    alertModule?.setUpScheduledAlertJobs?.();
+}
+export function refreshScheduledReportJobs(adaptable) {
+    const exportModule = adaptable.adaptableModules.get(ModuleConstants.ExportModuleId);
+    exportModule?.setUpScheduledReportJobs?.();
+}

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

@@ -0,0 +1,16 @@
+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;
+export declare function normalizeScheduledReportSchedule(schedule: ReportSchedule): ReportSchedule;
+export declare function getScheduledReports(exportState: ExportState): ReportSchedule[];
+export declare function exportStateNeedsScheduleUuids(exportState: ExportState): boolean;
+/**
+ * Assigns a unique {@link ReportSchedule.Uuid} to any schedule that lacks one.
+ * Required so edit/suspend/delete match a single schedule (not every `undefined` uuid).
+ */
+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/ScheduledReportHelper.js

@@ -0,0 +1,49 @@
+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;
+}
+export function getScheduledReports(exportState) {
+    return exportState.ReportSchedules ?? [];
+}
+function ensureScheduleUuid(schedule) {
+    return schedule.Uuid ? schedule : { ...schedule, Uuid: createUuid() };
+}
+export function exportStateNeedsScheduleUuids(exportState) {
+    return (exportState.ReportSchedules ?? []).some((schedule) => !schedule.Uuid);
+}
+/**
+ * Assigns a unique {@link ReportSchedule.Uuid} to any schedule that lacks one.
+ * Required so edit/suspend/delete match a single schedule (not every `undefined` uuid).
+ */
+export function ensureExportStateSchedulesUuids(exportState) {
+    if (!exportStateNeedsScheduleUuids(exportState)) {
+        return exportState;
+    }
+    return {
+        ...exportState,
+        ReportSchedules: (exportState.ReportSchedules ?? []).map(ensureScheduleUuid),
+    };
+}
+export function replaceScheduledReportScheduleInList(schedules, schedule) {
+    const index = schedules.findIndex((s) => s.Uuid === schedule.Uuid);
+    if (index < 0) {
+        return schedules;
+    }
+    const next = [...schedules];
+    next[index] = schedule;
+    return next;
+}
+export function countSchedulesForReport(exportState, reportName) {
+    return getScheduledReports(exportState).filter((s) => s.ReportName === reportName)
+        .length;
+}

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

@@ -1,4 +1,39 @@
 import { AdaptableStyle } from '../../types';
+import { CellBoxStyle, CellFontStyle } from '../../AdaptableState/Common/AdaptableStyle';
+/**
+ * Keys belonging to the "Font" slice (text rendering + alignment).
+ * See {@link CellFontStyle}.
+ */
+export declare const CELL_FONT_STYLE_KEYS: ReadonlyArray<keyof CellFontStyle>;
+/**
+ * Keys belonging to the "Cell" slice (cell chrome — background and border).
+ * See {@link CellBoxStyle}.
+ */
+export declare const CELL_BOX_STYLE_KEYS: ReadonlyArray<keyof CellBoxStyle>;
+/**
+ * Returns true when the given style has any property in the Font slice set.
+ */
+export declare const hasCellFontStyle: (style: Partial<CellFontStyle> | undefined) => boolean;
+/**
+ * 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

@@ -1,4 +1,87 @@
 import { EnumExtensions } from '../Extensions/EnumExtensions';
+/**
+ * Keys belonging to the "Font" slice (text rendering + alignment).
+ * See {@link CellFontStyle}.
+ */
+export const CELL_FONT_STYLE_KEYS = [
+    'ForeColor',
+    'FontWeight',
+    'FontStyle',
+    'TextDecoration',
+    'FontSize',
+    'Alignment',
+];
+/**
+ * Keys belonging to the "Cell" slice (cell chrome — background and border).
+ * See {@link CellBoxStyle}.
+ */
+export const CELL_BOX_STYLE_KEYS = [
+    'BackColor',
+    'BorderColor',
+    'BorderRadius',
+];
+const hasAtLeastOneKey = (obj, keys) => {
+    if (!obj) {
+        return false;
+    }
+    return keys.some((k) => obj[k] !== undefined && obj[k] !== null);
+};
+/**
+ * Returns true when the given style has any property in the Font slice set.
+ */
+export const hasCellFontStyle = (style) => hasAtLeastOneKey(style, CELL_FONT_STYLE_KEYS);
+/**
+ * Returns true when the given style has any property in the Cell (box) slice set.
+ */
+export const hasCellBoxStyle = (style) => hasAtLeastOneKey(style, CELL_BOX_STYLE_KEYS);
+/**
+ * Returns a copy of `style` containing only Font-slice 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;
+};
+/**
+ * Returns a copy of `style` containing only Cell-slice (box) keys.
+ */
+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;
+};
+/**
+ * Returns a copy of `style` with all Font-slice keys removed.
+ */
+export const omitCellFontStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    CELL_FONT_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
+/**
+ * Returns a copy of `style` with all Cell-slice (box) keys removed.
+ */
+export const omitCellBoxStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    CELL_BOX_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
 // required for hacky fix for https://github.com/AdaptableTools/adaptable/issues/2119
 export const AgGridCellStyleProperties = [
     'backgroundColor',

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

@@ -0,0 +1,30 @@
+import { CellColorRange, GradientStyle, NumericStyledColumn } from '../../AdaptableState/StyledColumnState';
+/**
+ * Default alpha at the **low** end of a Gradient range when `MinAlpha` is unset.
+ * Slightly above zero so the bottom-edge value of every range still shows its
+ * colour (rather than rendering fully transparent).
+ */
+export declare const DEFAULT_GRADIENT_MIN_ALPHA = 0.15;
+/**
+ * Default alpha at the **high** end of a Gradient range when `MaxAlpha` is unset.
+ */
+export declare const DEFAULT_GRADIENT_MAX_ALPHA = 1;
+/**
+ * Effective cell ranges for gradient rendering / range lookup.
+ * When `ZeroCentred` is set, expands to the canonical Col-Min…0 and 0…Col-Max bands.
+ */
+export declare function expandGradientCellRanges(gs: GradientStyle): CellColorRange[] | undefined;
+/**
+ * Value type passed to `findRangeForColumn` / `getCellColorRangeMinValue` /
+ * `getCellColorRangeMaxValue` when resolving which gradient band a cell falls in.
+ *
+ * Zero-centred bands use numeric `0` as an **absolute** zero crossing between
+ * `Col-Min…0` and `0…Col-Max`. Under `RangeValueType: 'Percentage'`, numeric
+ * endpoints are interpreted as % positions along the column min–max span, so
+ * literal `0` wrongly becomes `Col-Min` and the negative band collapses to a
+ * single point — boundary cells (e.g. the column minimum) pick up the negative
+ * colour incorrectly. Zero-centred lookup must always use Number semantics.
+ */
+export declare function gradientStyleRangeLookupValueType(gs: GradientStyle): NumericStyledColumn['RangeValueType'];
+/** The negative half of a zero-centred gradient (darker toward Col-Min). */
+export declare function isNegativeZeroCentredBand(range: CellColorRange): boolean;

package/src/Utilities/Helpers/StyledColumnGradientHelper.js

@@ -0,0 +1,41 @@
+/**
+ * Default alpha at the **low** end of a Gradient range when `MinAlpha` is unset.
+ * Slightly above zero so the bottom-edge value of every range still shows its
+ * colour (rather than rendering fully transparent).
+ */
+export const DEFAULT_GRADIENT_MIN_ALPHA = 0.15;
+/**
+ * Default alpha at the **high** end of a Gradient range when `MaxAlpha` is unset.
+ */
+export const DEFAULT_GRADIENT_MAX_ALPHA = 1;
+/**
+ * Effective cell ranges for gradient rendering / range lookup.
+ * When `ZeroCentred` is set, expands to the canonical Col-Min…0 and 0…Col-Max bands.
+ */
+export function expandGradientCellRanges(gs) {
+    if (gs.ZeroCentred) {
+        return [
+            { Min: 'Col-Min', Max: 0, Color: gs.ZeroCentred.NegativeColor },
+            { Min: 0, Max: 'Col-Max', Color: gs.ZeroCentred.PositiveColor },
+        ];
+    }
+    return gs.CellRanges;
+}
+/**
+ * Value type passed to `findRangeForColumn` / `getCellColorRangeMinValue` /
+ * `getCellColorRangeMaxValue` when resolving which gradient band a cell falls in.
+ *
+ * Zero-centred bands use numeric `0` as an **absolute** zero crossing between
+ * `Col-Min…0` and `0…Col-Max`. Under `RangeValueType: 'Percentage'`, numeric
+ * endpoints are interpreted as % positions along the column min–max span, so
+ * literal `0` wrongly becomes `Col-Min` and the negative band collapses to a
+ * single point — boundary cells (e.g. the column minimum) pick up the negative
+ * colour incorrectly. Zero-centred lookup must always use Number semantics.
+ */
+export function gradientStyleRangeLookupValueType(gs) {
+    return gs.ZeroCentred ? 'Number' : gs.RangeValueType ?? 'Number';
+}
+/** The negative half of a zero-centred gradient (darker toward Col-Min). */
+export function isNegativeZeroCentredBand(range) {
+    return range.Min === 'Col-Min' && range.Max === 0;
+}

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

@@ -0,0 +1,2 @@
+import { AlertButtonForm, AlertDefinition } from '../../AdaptableState/AlertState';
+export declare function resolveAlertFormForDefinition(alert: AlertDefinition, defaultForm: AlertButtonForm): string | AlertButtonForm;

package/src/Utilities/Helpers/alertFormHelper.js

@@ -0,0 +1,11 @@
+import { getScheduledAlertNotificationForm, isScheduledAlertDefinition, } from './ScheduledAlertHelper';
+export function resolveAlertFormForDefinition(alert, defaultForm) {
+    if (isScheduledAlertDefinition(alert)) {
+        if (!alert.AlertProperties?.DisplayNotification) {
+            return defaultForm;
+        }
+        return getScheduledAlertNotificationForm(alert.AlertProperties?.IncludeSuspendButton ?? false);
+    }
+    const ruleAlert = alert;
+    return ruleAlert.AlertForm ?? defaultForm;
+}