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

package/src/Utilities/Helpers/IconStylePresets.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICON_STYLE_PRESET_DESCRIPTIONS = exports.ICON_STYLE_PRESET_LABELS = exports.getIconStylePresetMappings = exports.ICON_STYLE_PRESETS = void 0;
+/**
+ * Built-in {@link IconStyle} mapping presets.
+ *
+ * The wizard's "Apply preset" action seeds `IconStyle.Mappings` from one
+ * of these. Once seeded the data is just normal mappings — users can add
+ * / edit / remove rows freely.
+ *
+ * Implementation notes:
+ *  - All icons here are emoji strings, so the presets cost nothing at
+ *    bundle / asset level. On Windows some flag emojis fall back to
+ *    regional-indicator letter pairs (e.g. "🇺🇸" → "US"), which is still
+ *    a sensible visual; users who want a consistent SVG flag pack across
+ *    platforms can swap individual mappings to URL icons.
+ *  - Presets are deliberately *small* — the most common values for each
+ *    domain. Users add the long tail by editing the mappings list.
+ */
+const flagEmoji = (countryCodeAlpha2) => {
+    const cc = countryCodeAlpha2.toUpperCase();
+    if (cc.length !== 2)
+        return cc;
+    // Convert ISO-3166 alpha-2 → regional indicator pair (each letter +
+    // 0x1F1A5). Browsers render this pair as the country flag.
+    const a = 0x1f1a5;
+    return String.fromCodePoint(a + cc.charCodeAt(0), a + cc.charCodeAt(1));
+};
+const FLAG_PRESET = [
+    { Key: 'AU', Icon: flagEmoji('AU'), Description: 'Australia' },
+    { Key: 'BE', Icon: flagEmoji('BE'), Description: 'Belgium' },
+    { Key: 'CA', Icon: flagEmoji('CA'), Description: 'Canada' },
+    { Key: 'CH', Icon: flagEmoji('CH'), Description: 'Switzerland' },
+    { Key: 'CN', Icon: flagEmoji('CN'), Description: 'China' },
+    { Key: 'DE', Icon: flagEmoji('DE'), Description: 'Germany' },
+    { Key: 'ES', Icon: flagEmoji('ES'), Description: 'Spain' },
+    { Key: 'FR', Icon: flagEmoji('FR'), Description: 'France' },
+    { Key: 'GB', Icon: flagEmoji('GB'), Description: 'United Kingdom' },
+    { Key: 'IE', Icon: flagEmoji('IE'), Description: 'Ireland' },
+    { Key: 'IT', Icon: flagEmoji('IT'), Description: 'Italy' },
+    { Key: 'JP', Icon: flagEmoji('JP'), Description: 'Japan' },
+    { Key: 'NL', Icon: flagEmoji('NL'), Description: 'Netherlands' },
+    { Key: 'PT', Icon: flagEmoji('PT'), Description: 'Portugal' },
+    { Key: 'US', Icon: flagEmoji('US'), Description: 'United States' },
+    // Friendly synonyms so the preset works against full country names too
+    // (`MatchMode: 'CaseInsensitive'` is a sensible default for this preset).
+    { Key: 'Australia', Icon: flagEmoji('AU'), Description: 'Australia' },
+    { Key: 'Belgium', Icon: flagEmoji('BE'), Description: 'Belgium' },
+    { Key: 'Canada', Icon: flagEmoji('CA'), Description: 'Canada' },
+    { Key: 'France', Icon: flagEmoji('FR'), Description: 'France' },
+    { Key: 'Germany', Icon: flagEmoji('DE'), Description: 'Germany' },
+    { Key: 'Italy', Icon: flagEmoji('IT'), Description: 'Italy' },
+    { Key: 'Japan', Icon: flagEmoji('JP'), Description: 'Japan' },
+    { Key: 'Spain', Icon: flagEmoji('ES'), Description: 'Spain' },
+    { Key: 'Switzerland', Icon: flagEmoji('CH'), Description: 'Switzerland' },
+    { Key: 'United Kingdom', Icon: flagEmoji('GB'), Description: 'United Kingdom' },
+    { Key: 'United States', Icon: flagEmoji('US'), Description: 'United States' },
+];
+// Currency → issuing country flag. Currency *symbols* (`$`, `¥`) are NOT
+// unique across currencies (USD/AUD/CAD/NZD all share `$`; CNY/JPY both use
+// `¥`), so an icon column built from symbols ends up visually ambiguous —
+// defeating the whole point of an icon column. Flags map 1-to-1 with the
+// issuing economy, give every currency a distinct glyph, and read instantly
+// in financial UIs (which is where this preset is most commonly used).
+//
+// Pair with `Description` ("US Dollar", "Euro") so tooltips / companion
+// text still surface the human-readable name. Anyone who prefers symbols
+// can still build that mapping by hand in the wizard.
+const CURRENCY_PRESET = [
+    { Key: 'AUD', Icon: flagEmoji('AU'), Description: 'Australian Dollar' },
+    { Key: 'CAD', Icon: flagEmoji('CA'), Description: 'Canadian Dollar' },
+    { Key: 'CHF', Icon: flagEmoji('CH'), Description: 'Swiss Franc' },
+    { Key: 'CNY', Icon: flagEmoji('CN'), Description: 'Chinese Yuan' },
+    // 'EU' as a regional indicator pair renders as the EU flag in modern
+    // emoji fonts; falls back to the letters "EU" otherwise — still readable.
+    { Key: 'EUR', Icon: flagEmoji('EU'), Description: 'Euro' },
+    { Key: 'GBP', Icon: flagEmoji('GB'), Description: 'British Pound' },
+    { Key: 'HKD', Icon: flagEmoji('HK'), Description: 'Hong Kong Dollar' },
+    { Key: 'INR', Icon: flagEmoji('IN'), Description: 'Indian Rupee' },
+    { Key: 'JPY', Icon: flagEmoji('JP'), Description: 'Japanese Yen' },
+    { Key: 'KRW', Icon: flagEmoji('KR'), Description: 'South Korean Won' },
+    { Key: 'MXN', Icon: flagEmoji('MX'), Description: 'Mexican Peso' },
+    { Key: 'NOK', Icon: flagEmoji('NO'), Description: 'Norwegian Krone' },
+    { Key: 'NZD', Icon: flagEmoji('NZ'), Description: 'New Zealand Dollar' },
+    { Key: 'RUB', Icon: flagEmoji('RU'), Description: 'Russian Ruble' },
+    { Key: 'SEK', Icon: flagEmoji('SE'), Description: 'Swedish Krona' },
+    { Key: 'SGD', Icon: flagEmoji('SG'), Description: 'Singapore Dollar' },
+    { Key: 'TRY', Icon: flagEmoji('TR'), Description: 'Turkish Lira' },
+    { Key: 'USD', Icon: flagEmoji('US'), Description: 'US Dollar' },
+    { Key: 'ZAR', Icon: flagEmoji('ZA'), Description: 'South African Rand' },
+];
+const TREND_PRESET = [
+    { Key: 'Up', Icon: '⬆', Description: 'Up' },
+    { Key: 'Down', Icon: '⬇', Description: 'Down' },
+    { Key: 'Flat', Icon: '➡', Description: 'Flat' },
+    // Trading-side synonyms so the same preset works against Buy/Sell columns.
+    { Key: 'Buy', Icon: '⬆', Description: 'Buy' },
+    { Key: 'Sell', Icon: '⬇', Description: 'Sell' },
+    { Key: 'Hold', Icon: '➡', Description: 'Hold' },
+    { Key: 'Long', Icon: '⬆', Description: 'Long' },
+    { Key: 'Short', Icon: '⬇', Description: 'Short' },
+];
+const STATUS_PRESET = [
+    { Key: 'Pass', Icon: '🟢', Description: 'Pass' },
+    { Key: 'Warn', Icon: '🟡', Description: 'Warn' },
+    { Key: 'Fail', Icon: '🔴', Description: 'Fail' },
+    // Status-column synonyms (cover the `status` column in the trade demo).
+    { Key: 'Completed', Icon: '🟢', Description: 'Completed' },
+    { Key: 'In Progress', Icon: '🟡', Description: 'In Progress' },
+    { Key: 'Pending', Icon: '🟡', Description: 'Pending' },
+    { Key: 'Booked', Icon: '🟢', Description: 'Booked' },
+    { Key: 'Rejected', Icon: '🔴', Description: 'Rejected' },
+];
+exports.ICON_STYLE_PRESETS = {
+    Flags: FLAG_PRESET,
+    Currencies: CURRENCY_PRESET,
+    Trend: TREND_PRESET,
+    Status: STATUS_PRESET,
+};
+/** Returns a fresh copy of the mappings for a given preset. */
+const getIconStylePresetMappings = (preset) => {
+    return exports.ICON_STYLE_PRESETS[preset].map((m) => ({ ...m }));
+};
+exports.getIconStylePresetMappings = getIconStylePresetMappings;
+exports.ICON_STYLE_PRESET_LABELS = {
+    Flags: 'Country Flags',
+    Currencies: 'Currencies',
+    Trend: 'Trend / Direction',
+    Status: 'Status',
+};
+exports.ICON_STYLE_PRESET_DESCRIPTIONS = {
+    Flags: 'ISO country code or country name → flag emoji',
+    Currencies: 'ISO 4217 currency code → issuing country flag',
+    Trend: 'Up / Down / Flat (and Buy / Sell / Hold) → arrows',
+    Status: 'Pass / Warn / Fail (and common synonyms) → traffic light',
+};

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

@@ -0,0 +1,12 @@
+import { AdaptableStyle } from '../../AdaptableState/Common/AdaptableStyle';
+import { QuickSearchState } from '../../AdaptableState/QuickSearchState';
+/** True when no style properties are set (including persisted `{}` placeholders). */
+export declare function isQuickSearchStyleUnset(style: Omit<AdaptableStyle, 'ClassName'> | undefined): boolean;
+/** Matching text highlight (AG Grid Find). Defaults at read time — not written to state unless set. */
+export declare function resolveQuickSearchTextMatchStyle(quickSearchState: QuickSearchState): Omit<AdaptableStyle, 'ClassName'>;
+/** Whole-cell background on matching cells. Undefined when unset (client-side). */
+export declare function resolveQuickSearchCellMatchStyle(quickSearchState: QuickSearchState): Omit<AdaptableStyle, 'ClassName'> | undefined;
+/** Active match text highlight when cycling results. Defaults at read time. */
+export declare function resolveQuickSearchCurrentTextMatchStyle(quickSearchState: QuickSearchState): Omit<AdaptableStyle, 'ClassName'>;
+/** Apply Quick Search Find CSS variables on the grid container (`.ab-Grid`). */
+export declare function applyQuickSearchFindCssVars(container: HTMLElement | null, quickSearchState: QuickSearchState): void;

package/src/Utilities/Helpers/QuickSearchStyleHelper.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isQuickSearchStyleUnset = isQuickSearchStyleUnset;
+exports.resolveQuickSearchTextMatchStyle = resolveQuickSearchTextMatchStyle;
+exports.resolveQuickSearchCellMatchStyle = resolveQuickSearchCellMatchStyle;
+exports.resolveQuickSearchCurrentTextMatchStyle = resolveQuickSearchCurrentTextMatchStyle;
+exports.applyQuickSearchFindCssVars = applyQuickSearchFindCssVars;
+const tslib_1 = require("tslib");
+const QuickSearchRedux_1 = require("../../Redux/ActionsReducers/QuickSearchRedux");
+const StyleHelper_1 = require("./StyleHelper");
+const kebabCase_1 = tslib_1.__importDefault(require("../utils/kebabCase"));
+const QUICK_SEARCH_FIND_CSS_KEYS = [
+    'backgroundColor',
+    'color',
+    'fontWeight',
+    'fontStyle',
+    'fontSize',
+    'textDecoration',
+    'borderColor',
+    'borderRadius',
+];
+/** True when no style properties are set (including persisted `{}` placeholders). */
+function isQuickSearchStyleUnset(style) {
+    if (style == null) {
+        return true;
+    }
+    return !Object.entries(style).some(([key, value]) => {
+        if (value == null || value === '') {
+            return false;
+        }
+        if (key === 'Alignment' && value === 'Default') {
+            return false;
+        }
+        if (key === 'TextDecoration' && value === 'None') {
+            return false;
+        }
+        if (key === 'FontWeight' && value === 'Normal') {
+            return false;
+        }
+        if (key === 'FontStyle' && value === 'Normal') {
+            return false;
+        }
+        if (key === 'BorderRadius' && value === 0) {
+            return false;
+        }
+        return true;
+    });
+}
+/** Matching text highlight (AG Grid Find). Defaults at read time — not written to state unless set. */
+function resolveQuickSearchTextMatchStyle(quickSearchState) {
+    if (isQuickSearchStyleUnset(quickSearchState.TextMatchStyle)) {
+        return QuickSearchRedux_1.QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE;
+    }
+    return quickSearchState.TextMatchStyle;
+}
+/** Whole-cell background on matching cells. Undefined when unset (client-side). */
+function resolveQuickSearchCellMatchStyle(quickSearchState) {
+    if (isQuickSearchStyleUnset(quickSearchState.CellMatchStyle)) {
+        return undefined;
+    }
+    return quickSearchState.CellMatchStyle;
+}
+/** Active match text highlight when cycling results. Defaults at read time. */
+function resolveQuickSearchCurrentTextMatchStyle(quickSearchState) {
+    if (isQuickSearchStyleUnset(quickSearchState.CurrentTextMatchStyle)) {
+        return QuickSearchRedux_1.QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE;
+    }
+    return quickSearchState.CurrentTextMatchStyle;
+}
+/** Apply Quick Search Find CSS variables on the grid container (`.ab-Grid`). */
+function applyQuickSearchFindCssVars(container, quickSearchState) {
+    if (!container) {
+        return;
+    }
+    const textStyle = resolveQuickSearchTextMatchStyle(quickSearchState);
+    const currentStyle = resolveQuickSearchCurrentTextMatchStyle(quickSearchState);
+    applyQuickSearchFindCssVarsForPrefix(container, 'text', (0, StyleHelper_1.convertAdaptableStyleToCSS)(textStyle));
+    applyQuickSearchFindCssVarsForPrefix(container, 'current', (0, StyleHelper_1.convertAdaptableStyleToCSS)(currentStyle));
+}
+function applyQuickSearchFindCssVarsForPrefix(container, prefix, css) {
+    QUICK_SEARCH_FIND_CSS_KEYS.forEach((key) => {
+        container.style.setProperty(`--ab-qs-${prefix}-${(0, kebabCase_1.default)(key)}`, css[key] ?? '');
+    });
+}

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

@@ -0,0 +1,22 @@
+import { Schedule, Weekday } from '../../AdaptableState/Common/Schedule';
+export type ScheduleRecurrencePreset = 'daily' | 'weekdays' | 'selectedDays' | 'monthly' | 'custom';
+export declare function buildCronExpression(preset: ScheduleRecurrencePreset, hour: number, minute: number, options?: {
+    days?: Weekday[];
+    dayOfMonth?: number;
+    customExpression?: string;
+}): string;
+export declare function buildRunAtIso(date: string, hour: number, minute: number): string;
+export declare function parseTimeFromSchedule(schedule: Schedule): {
+    hour: number;
+    minute: number;
+};
+export declare function inferPresetFromCron(cronExpression?: string): {
+    preset: ScheduleRecurrencePreset;
+    days: Weekday[];
+    dayOfMonth: number;
+};
+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/ScheduleHelper.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCronExpression = buildCronExpression;
+exports.buildRunAtIso = buildRunAtIso;
+exports.parseTimeFromSchedule = parseTimeFromSchedule;
+exports.inferPresetFromCron = inferPresetFromCron;
+exports.parseOneOffDateFromRunAt = parseOneOffDateFromRunAt;
+exports.getNextRunDateFromSchedule = getNextRunDateFromSchedule;
+exports.isScheduleValid = isScheduleValid;
+exports.getScheduleDescription = getScheduleDescription;
+exports.isValidCronExpression = isValidCronExpression;
+const tslib_1 = require("tslib");
+const cron_parser_1 = require("cron-parser");
+const StringExtensions_1 = tslib_1.__importDefault(require("../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',
+];
+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} * * *`;
+    }
+}
+function buildRunAtIso(date, hour, minute) {
+    const d = new Date(date);
+    d.setHours(clampHour(hour), clampMinute(minute), 0, 0);
+    return d.toISOString();
+}
+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 };
+}
+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 };
+}
+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}`;
+}
+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 = (0, cron_parser_1.parseExpression)(schedule.CronExpression.trim(), {
+            currentDate: new Date(),
+        });
+        const next = interval.next().toDate();
+        return next > new Date() ? next : null;
+    }
+    catch {
+        return null;
+    }
+}
+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 {
+        (0, cron_parser_1.parseExpression)(schedule.CronExpression.trim());
+        return true;
+    }
+    catch {
+        return 'Cron expression is not valid';
+    }
+}
+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));
+}
+function isValidCronExpression(expression) {
+    if (StringExtensions_1.default.IsNullOrEmpty(expression)) {
+        return false;
+    }
+    try {
+        (0, cron_parser_1.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,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScheduleJobManager = createScheduleJobManager;
+const ScheduleJobRunner_1 = require("./ScheduleJobRunner");
+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_1.ScheduleJobRunner.getNextRunDate(schedule);
+            if (date != null) {
+                jobs.push(ScheduleJobRunner_1.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,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleJobRunner = void 0;
+const ScheduleHelper_1 = require("./ScheduleHelper");
+const dateTimeouts = {};
+exports.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 (0, ScheduleHelper_1.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,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScheduledAlertDefinition = isScheduledAlertDefinition;
+exports.isRuleBasedAlertDefinition = isRuleBasedAlertDefinition;
+exports.getRuleAlertProperties = getRuleAlertProperties;
+exports.getActiveScheduledAlertDefinitions = getActiveScheduledAlertDefinitions;
+exports.getScheduledAlertNotificationForm = getScheduledAlertNotificationForm;
+exports.scheduledAlertIncludeSuspendButton = scheduledAlertIncludeSuspendButton;
+exports.CreateEmptyScheduledAlertDefinition = CreateEmptyScheduledAlertDefinition;
+const tslib_1 = require("tslib");
+const ObjectFactory_1 = tslib_1.__importDefault(require("../ObjectFactory"));
+const GeneralConstants_1 = require("../Constants/GeneralConstants");
+const ObjectDefaultConstants_1 = require("../Constants/ObjectDefaultConstants");
+const Uuid_1 = require("../../AdaptableState/Uuid");
+function isScheduledAlertDefinition(alert) {
+    return alert != null && 'Schedule' in alert;
+}
+function isRuleBasedAlertDefinition(alert) {
+    return alert != null && 'Rule' in alert;
+}
+function getRuleAlertProperties(alert) {
+    return isRuleBasedAlertDefinition(alert) ? alert.AlertProperties : undefined;
+}
+function getActiveScheduledAlertDefinitions(alerts) {
+    return alerts.filter((a) => !a.IsSuspended && isScheduledAlertDefinition(a));
+}
+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 };
+}
+function scheduledAlertIncludeSuspendButton(alert) {
+    return alert.AlertProperties?.IncludeSuspendButton ?? false;
+}
+function CreateEmptyScheduledAlertDefinition(name) {
+    const displayName = name?.trim() || '';
+    return {
+        Uuid: (0, Uuid_1.createUuid)(),
+        Name: displayName || GeneralConstants_1.EMPTY_STRING,
+        MessageType: ObjectDefaultConstants_1.ALERT_DEFAULT_MESSAGE_TYPE,
+        Schedule: ObjectFactory_1.default.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;