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

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

@@ -0,0 +1,14 @@
+import { ChartRef } from 'ag-grid-enterprise';
+import { ChartDefinition, ExternalChartDefinition } from '../../AdaptableState/ChartingState';
+import { Layout, LayoutOpenChart } from '../../AdaptableState/LayoutState';
+import { AdaptableApi } from '../../Api/AdaptableApi';
+export declare function closeAgChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ChartDefinition): void;
+export declare function closeExternalChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ExternalChartDefinition): void;
+export declare function closeChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ChartDefinition | ExternalChartDefinition): void;
+export declare function closeAllOpenAgCharts(api: AdaptableApi): void;
+export declare function isChartNameTaken(api: AdaptableApi, name: string, excludeUuid?: string): boolean;
+export declare function validateChartName(api: AdaptableApi, name: string, excludeUuid?: string): true | string;
+export declare function resolveAgChartDefinitionByName(api: AdaptableApi, chartName: string): ChartDefinition | undefined;
+export declare function showChartDefinitions(api: AdaptableApi, chartDefinitions: ChartDefinition[], openCharts?: LayoutOpenChart[]): ChartRef[];
+export declare function restoreChartsOnReady(api: AdaptableApi): void;
+export declare function openLayoutCharts(api: AdaptableApi, layout: Layout | undefined): void;

package/src/Utilities/Helpers/chartingHelper.js

@@ -0,0 +1,112 @@
+import { isAgChartDefinition, isExternalChartDefinition, } from '../../AdaptableState/ChartingState';
+import StringExtensions from '../Extensions/StringExtensions';
+export function closeAgChartDefinitionIfOpen(api, chartDefinition) {
+    const chartId = chartDefinition?.Model?.chartId;
+    if (!chartId) {
+        return;
+    }
+    const chartRef = api.chartingApi.getChartRef(chartId);
+    chartRef?.destroyChart();
+}
+export function closeExternalChartDefinitionIfOpen(api, chartDefinition) {
+    if (api.chartingApi.internalApi.isExternalChartOpened(chartDefinition)) {
+        api.chartingApi.internalApi.onHideExternalChart(chartDefinition);
+    }
+}
+export function closeChartDefinitionIfOpen(api, chartDefinition) {
+    if (isAgChartDefinition(chartDefinition)) {
+        closeAgChartDefinitionIfOpen(api, chartDefinition);
+    }
+    else if (isExternalChartDefinition(chartDefinition)) {
+        closeExternalChartDefinitionIfOpen(api, chartDefinition);
+    }
+}
+export function closeAllOpenAgCharts(api) {
+    api.chartingApi.getCurrentChartModels().forEach((model) => {
+        api.chartingApi.getChartRef(model.chartId)?.destroyChart();
+    });
+}
+export function isChartNameTaken(api, name, excludeUuid) {
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+        return false;
+    }
+    return [...api.chartingApi.getChartDefinitions(), ...api.chartingApi.getExternalChartDefinitions()]
+        .filter((chart) => chart.Uuid !== excludeUuid)
+        .some((chart) => chart.Name === trimmedName);
+}
+export function validateChartName(api, name, excludeUuid) {
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+        return 'A name is required.';
+    }
+    if (isChartNameTaken(api, trimmedName, excludeUuid)) {
+        return 'A chart with this name already exists.';
+    }
+    return true;
+}
+export function resolveAgChartDefinitionByName(api, chartName) {
+    if (!StringExtensions.IsNotNullOrEmpty(chartName)) {
+        return undefined;
+    }
+    return api.chartingApi.getChartDefinitionByName(chartName.trim());
+}
+function resolveChartDefinitionsToRestore(api, restoreChartsOnReady) {
+    const allCharts = api.chartingApi.getChartDefinitions();
+    if (!restoreChartsOnReady) {
+        return [];
+    }
+    if (restoreChartsOnReady === true || restoreChartsOnReady === 'all') {
+        return allCharts;
+    }
+    if (Array.isArray(restoreChartsOnReady)) {
+        return restoreChartsOnReady
+            .map((chartName) => resolveAgChartDefinitionByName(api, chartName))
+            .filter(Boolean);
+    }
+    return [];
+}
+function resolveContainerElement(api, containerName) {
+    if (!StringExtensions.IsNotNullOrEmpty(containerName)) {
+        return undefined;
+    }
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    if (containerName === chartingOptions.agGridContainerName) {
+        return undefined;
+    }
+    return api.chartingApi.internalApi.getContainerElemetnByName(containerName) ?? undefined;
+}
+export function showChartDefinitions(api, chartDefinitions, openCharts) {
+    const refs = [];
+    chartDefinitions.forEach((chartDefinition) => {
+        const openSpec = openCharts?.find((openChart) => openChart.ChartName === chartDefinition.Name);
+        const container = resolveContainerElement(api, openSpec?.ContainerName);
+        const chartRef = api.chartingApi.showChartDefinitionOnce(chartDefinition, container);
+        if (chartRef) {
+            refs.push(chartRef);
+        }
+    });
+    return refs;
+}
+export function restoreChartsOnReady(api) {
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    const chartsToRestore = resolveChartDefinitionsToRestore(api, chartingOptions.restoreChartsOnReady);
+    if (!chartsToRestore.length) {
+        return;
+    }
+    showChartDefinitions(api, chartsToRestore);
+}
+export function openLayoutCharts(api, layout) {
+    if (!layout || layout.OpenCharts === undefined) {
+        return;
+    }
+    closeAllOpenAgCharts(api);
+    if (!layout.OpenCharts.length) {
+        return;
+    }
+    const chartsToOpen = layout.OpenCharts.map((openChart) => resolveAgChartDefinitionByName(api, openChart.ChartName)).filter(Boolean);
+    if (!chartsToOpen.length) {
+        return;
+    }
+    showChartDefinitions(api, chartsToOpen, layout.OpenCharts);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Icon Column Style resolves one key → glyph per scalar cell value; AdapTable
+ * array column types are not supported (use Badge Style for per-element visuals).
+ */
+export declare function isUnsupportedColumnDataTypeForIconStyle(dataType?: string): boolean;

package/src/Utilities/Helpers/iconStyledColumnColumnSupport.js

@@ -0,0 +1,15 @@
+/**
+ * Icon Column Style resolves one key → glyph per scalar cell value; AdapTable
+ * array column types are not supported (use Badge Style for per-element visuals).
+ */
+export function isUnsupportedColumnDataTypeForIconStyle(dataType) {
+    switch (dataType) {
+        case 'textArray':
+        case 'numberArray':
+        case 'tupleArray':
+        case 'objectArray':
+            return true;
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { EditOptions, PlusMinusOptions } from '../../AdaptableOptions/EditOptions';
+import type { PlusMinusNudge } from '../../AdaptableState/PlusMinusState';
+/**
+ * Resolve increment/decrement trigger strings for a single nudge.
+ * Per-nudge fields win; otherwise {@link PlusMinusOptions}; otherwise `+` / `-`.
+ */
+export declare function resolvePlusMinusTriggerKeysForNudge(nudge: Pick<PlusMinusNudge, 'IncrementKey' | 'DecrementKey'>, globalOptions: Readonly<EditOptions['plusMinusOptions']> | undefined): {
+    incrementKey: string;
+    decrementKey: string;
+};
+/** True when resolved increment and decrement would match the same key press. */
+export declare function plusMinusResolvedKeysConflict(nudge: Pick<PlusMinusNudge, 'IncrementKey' | 'DecrementKey'>, globalOptions: Readonly<EditOptions['plusMinusOptions']> | undefined): boolean;
+/**
+ * Match a pressed key against a configured trigger. Single-character keys are
+ * compared case-insensitively (aligned with Shortcut module behaviour).
+ */
+export declare function plusMinusKeyMatches(actualKey: string, configuredKey: string): boolean;
+/** Increment key from `AdaptableOptions.plusMinusOptions` only, then built-in `+`. */
+export declare function plusMinusIncrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
+/** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
+export declare function plusMinusDecrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
+/**
+ * True when `candidate` is the same trigger as `baseline` for “no nudge override to persist”
+ * (single-character keys compared case-insensitively, same as {@link plusMinusKeyMatches}).
+ */
+export declare function plusMinusTriggerSameAsBaseline(candidate: string, baseline: string): boolean;
+/**
+ * Precomputed keys for fast keydown filtering (mirrors {@link plusMinusKeyMatches} semantics).
+ * Single-character triggers are stored lowercased; longer triggers are exact strings.
+ */
+export type PlusMinusTriggerKeyLookup = {
+    singleCharLower: Set<string>;
+    exactKeys: Set<string>;
+};
+/** Build a lookup of all increment/decrement keys across active nudges (resolved). */
+export declare function buildPlusMinusTriggerKeyLookup(nudges: PlusMinusNudge[], globalOptions: Readonly<PlusMinusOptions> | undefined): PlusMinusTriggerKeyLookup;
+/**
+ * O(1) check: whether this pressed key could match any configured Plus Minus trigger.
+ * When false, skip fetching cells / running nudge rules.
+ */
+export declare function plusMinusKeyCouldTrigger(keyEventString: string, lookup: PlusMinusTriggerKeyLookup): boolean;

package/src/Utilities/Helpers/plusMinusTriggerKeys.js

@@ -0,0 +1,90 @@
+const DEFAULT_INCREMENT_KEY = '+';
+const DEFAULT_DECREMENT_KEY = '-';
+/**
+ * Resolve increment/decrement trigger strings for a single nudge.
+ * Per-nudge fields win; otherwise {@link PlusMinusOptions}; otherwise `+` / `-`.
+ */
+export function resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions) {
+    const incrementKey = nudge.IncrementKey?.trim() || plusMinusIncrementKeyFromOptionsOnly(globalOptions);
+    const decrementKey = nudge.DecrementKey?.trim() || plusMinusDecrementKeyFromOptionsOnly(globalOptions);
+    return { incrementKey, decrementKey };
+}
+/** True when resolved increment and decrement would match the same key press. */
+export function plusMinusResolvedKeysConflict(nudge, globalOptions) {
+    const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
+    if (incrementKey === decrementKey) {
+        return true;
+    }
+    if (incrementKey.length === 1 && decrementKey.length === 1) {
+        return incrementKey.toLowerCase() === decrementKey.toLowerCase();
+    }
+    return false;
+}
+/**
+ * Match a pressed key against a configured trigger. Single-character keys are
+ * compared case-insensitively (aligned with Shortcut module behaviour).
+ */
+export function plusMinusKeyMatches(actualKey, configuredKey) {
+    if (!configuredKey) {
+        return false;
+    }
+    if (actualKey === configuredKey) {
+        return true;
+    }
+    if (configuredKey.length === 1 && actualKey.length === 1) {
+        return actualKey.toLowerCase() === configuredKey.toLowerCase();
+    }
+    return false;
+}
+/** Increment key from `AdaptableOptions.plusMinusOptions` only, then built-in `+`. */
+export function plusMinusIncrementKeyFromOptionsOnly(globalOptions) {
+    return globalOptions?.incrementKey?.trim() || DEFAULT_INCREMENT_KEY;
+}
+/** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
+export function plusMinusDecrementKeyFromOptionsOnly(globalOptions) {
+    return globalOptions?.decrementKey?.trim() || DEFAULT_DECREMENT_KEY;
+}
+/**
+ * True when `candidate` is the same trigger as `baseline` for “no nudge override to persist”
+ * (single-character keys compared case-insensitively, same as {@link plusMinusKeyMatches}).
+ */
+export function plusMinusTriggerSameAsBaseline(candidate, baseline) {
+    return plusMinusKeyMatches(candidate, baseline) && plusMinusKeyMatches(baseline, candidate);
+}
+function addConfiguredKeyToLookup(lookup, configuredKey) {
+    if (!configuredKey) {
+        return;
+    }
+    if (configuredKey.length === 1) {
+        lookup.singleCharLower.add(configuredKey.toLowerCase());
+    }
+    else {
+        lookup.exactKeys.add(configuredKey);
+    }
+}
+/** Build a lookup of all increment/decrement keys across active nudges (resolved). */
+export function buildPlusMinusTriggerKeyLookup(nudges, globalOptions) {
+    const lookup = {
+        singleCharLower: new Set(),
+        exactKeys: new Set(),
+    };
+    for (const nudge of nudges) {
+        const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
+        addConfiguredKeyToLookup(lookup, incrementKey);
+        addConfiguredKeyToLookup(lookup, decrementKey);
+    }
+    return lookup;
+}
+/**
+ * O(1) check: whether this pressed key could match any configured Plus Minus trigger.
+ * When false, skip fetching cells / running nudge rules.
+ */
+export function plusMinusKeyCouldTrigger(keyEventString, lookup) {
+    if (!keyEventString) {
+        return false;
+    }
+    if (keyEventString.length === 1) {
+        return lookup.singleCharLower.has(keyEventString.toLowerCase());
+    }
+    return lookup.exactKeys.has(keyEventString);
+}

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

@@ -0,0 +1,25 @@
+import type { IRowNode } from 'ag-grid-enterprise';
+import type { AdaptableApi } from '../../Api/AdaptableApi';
+import type { StyledColumn } from '../../AdaptableState/StyledColumnState';
+import type { RowScope } from '../../AdaptableState/Common/RowScope';
+/**
+ * Row kinds used by {@link RowScope} and the Styled Column Scope wizard.
+ * All are available to all Styled Columns with exception of Sparkline (which is data rows only)
+ */
+export type StyledColumnRowKind = 'Data' | 'Group' | 'Summary' | 'Total';
+export declare const STYLED_COLUMN_ROW_KINDS: StyledColumnRowKind[];
+export declare const STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY: Record<StyledColumnRowKind, keyof RowScope>;
+export declare const isStyledColumnRowKindSupported: (styledColumn: StyledColumn, kind: StyledColumnRowKind) => boolean;
+export declare const getStyledColumnRowKindDisabledReason: (styledColumn: StyledColumn, kind: StyledColumnRowKind) => string | undefined;
+/**
+ * Classifies the AG Grid row node into a single {@link StyledColumnRowKind}.
+ * Order matches {@link shouldRenderStyledColumnOnRow}: total before summary,
+ * summary before group.
+ */
+export declare const getStyledColumnRowKindForNode: (node: IRowNode, api: AdaptableApi) => StyledColumnRowKind;
+/**
+ * Forces `Exclude*` to `true` for row kinds that do not apply to the current
+ * Styled Column type, so persisted state cannot contradict the capability
+ * matrix. Returns `undefined` when no change is needed.
+ */
+export declare const sanitizeStyledColumnRowScope: (styledColumn: StyledColumn) => RowScope | undefined;

package/src/Utilities/Helpers/styledColumnRowKindSupport.js

@@ -0,0 +1,63 @@
+export const STYLED_COLUMN_ROW_KINDS = ['Data', 'Group', 'Summary', 'Total'];
+export const STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY = {
+    Data: 'ExcludeDataRows',
+    Group: 'ExcludeGroupRows',
+    Summary: 'ExcludeSummaryRows',
+    Total: 'ExcludeTotalRows',
+};
+export const isStyledColumnRowKindSupported = (styledColumn, kind) => {
+    if (styledColumn.SparklineStyle) {
+        return kind === 'Data';
+    }
+    return true;
+};
+export const getStyledColumnRowKindDisabledReason = (styledColumn, kind) => {
+    if (isStyledColumnRowKindSupported(styledColumn, kind)) {
+        return undefined;
+    }
+    if (styledColumn.SparklineStyle) {
+        return 'Sparklines only apply to leaf data rows (cells with a numeric array of points).';
+    }
+    return undefined;
+};
+/**
+ * Classifies the AG Grid row node into a single {@link StyledColumnRowKind}.
+ * Order matches {@link shouldRenderStyledColumnOnRow}: total before summary,
+ * summary before group.
+ */
+export const getStyledColumnRowKindForNode = (node, api) => {
+    if (api.gridApi.isGrandTotalRowNode(node)) {
+        return 'Total';
+    }
+    if (api.gridApi.isSummaryNode(node)) {
+        return 'Summary';
+    }
+    if (api.gridApi.isGroupRowNode(node)) {
+        return 'Group';
+    }
+    return 'Data';
+};
+/**
+ * Forces `Exclude*` to `true` for row kinds that do not apply to the current
+ * Styled Column type, so persisted state cannot contradict the capability
+ * matrix. Returns `undefined` when no change is needed.
+ */
+export const sanitizeStyledColumnRowScope = (styledColumn) => {
+    const scope = styledColumn.RowScope;
+    if (!scope) {
+        return undefined;
+    }
+    let next = { ...scope };
+    let changed = false;
+    for (const kind of STYLED_COLUMN_ROW_KINDS) {
+        if (isStyledColumnRowKindSupported(styledColumn, kind)) {
+            continue;
+        }
+        const key = STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY[kind];
+        if (next[key] !== true) {
+            next = { ...next, [key]: true };
+            changed = true;
+        }
+    }
+    return changed ? next : undefined;
+};

package/src/Utilities/ObjectFactory.d.ts

@@ -1,24 +1,19 @@
-import { AlertDefinition, AlertProperties } from '../AdaptableState/AlertState';
+import { AlertDefinition, RuleAlertProperties, RuleBasedAlertDefinition } from '../AdaptableState/AlertState';
 import { CalculatedColumn } from '../AdaptableState/CalculatedColumnState';
 import { AdaptableCellChangedAlert, AdaptableGenericAlert, AdaptableRowChangedAlert } from '../AdaptableState/Common/AdaptableAlert';
 import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
 import { AdaptableStyle } from '../AdaptableState/Common/AdaptableStyle';
 import { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChangedInfo';
-import { ScheduleType } from '../AdaptableState/Common/Enums';
-import { BaseSchedule, Schedule } from '../AdaptableState/Common/Schedule';
+import { Schedule } from '../AdaptableState/Common/Schedule';
 import { SystemStatusMessageInfo } from '../AdaptableState/Common/SystemStatusMessageInfo';
 import { CustomSort } from '../AdaptableState/CustomSortState';
 import { Report, ReportFormatType, ReportNameType, ReportSchedule } from '../AdaptableState/ExportState';
 import { FormatColumn } from '../AdaptableState/FormatColumnState';
 import { FreeTextColumn } from '../AdaptableState/FreeTextColumnState';
-import { IPushPullSchedule } from '../AdaptableState/IPushPullState';
 import { Layout } from '../AdaptableState/LayoutState';
-import { OpenFinReport, OpenFinSchedule } from '../AdaptableState/OpenFinState';
 import { PlusMinusNudge } from '../AdaptableState/PlusMinusState';
-import { ReminderSchedule } from '../AdaptableState/ScheduleState';
 import { Shortcut } from '../AdaptableState/ShortcutState';
-import { IPushPullReport } from '../AdaptableState/InternalState';
 import { NotificationsOptions } from '../AdaptableOptions/NotificationsOptions';
 import { CellSummmaryInfo } from '../AdaptableState/Common/CellSummary';
 import { AdaptableTheme, ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, RowDataChangedInfo, SpecialColumnSettings, SystemFilterPredicateId } from '../types';
@@ -34,20 +29,11 @@ export declare function CreateEmptyPlusMinusNudge(): PlusMinusNudge;
 export declare function CreateGenericAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition): AdaptableGenericAlert;
 export declare function CreateCellChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, cellDataChangedInfo: CellDataChangedInfo): AdaptableCellChangedAlert;
 export declare function CreateRowChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, rowDataChangedInfo: RowDataChangedInfo): AdaptableRowChangedAlert;
-export declare function CreateEmptyAlertDefinition(): AlertDefinition;
+export declare function CreateEmptyAlertDefinition(): RuleBasedAlertDefinition;
 export declare function CreateEmptyFlashingCellDefinition(): FlashingCellDefinition;
-export declare function CreateInternalAlertDefinitionForMessages(messageType: AdaptableMessageType, alertProperties?: AlertProperties): AlertDefinition;
+export declare function CreateInternalAlertDefinitionForMessages(messageType: AdaptableMessageType, alertProperties?: RuleAlertProperties): RuleBasedAlertDefinition;
 export declare function CreateEmptyReport(): Report;
-export declare function CreateEmptyBaseSchedule(scheduleType: ScheduleType): BaseSchedule;
-export declare function CreateEmptyReminderSchedule(): ReminderSchedule;
-export declare function CreateEmptyReportSchedule(): ReportSchedule;
-export declare function CreateEmptyIPushPullReport(): IPushPullReport;
-export declare function CreateEmptyOpenFinReport(): OpenFinReport;
-export declare function CreateEmptyIPushPullSchedule(): IPushPullSchedule;
-export declare function CreateEmptyOpenFinSchedule(): OpenFinSchedule;
-export declare function CreateIPushPullSchedule(iPushPullReport: IPushPullReport): IPushPullSchedule;
-export declare function CreateReportSchedule(reportName: ReportNameType, reportFormat: ReportFormatType): ReportSchedule;
-export declare function CreateEmptySchedule(): Schedule;
+export declare function CreateEmptyReportSchedule(reportFormat?: ReportFormatType, reportName?: ReportNameType): ReportSchedule;
 export declare function CreateEmptyShortcut(): Shortcut;
 export declare function CreateEmptyFormatColumn(): FormatColumn;
 export declare function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings: Partial<SpecialColumnSettings>): FreeTextColumn;
@@ -76,6 +62,7 @@ export declare function CreateToastOptions(notificationsOptions: NotificationsOp
 }, overides?: {
     duration: number | 'always';
 }): ToastOptions;
+export declare function CreateDefaultSchedule(): Schedule;
 export declare const ObjectFactory: {
     CreateEmptyCustomSort: typeof CreateEmptyCustomSort;
     CreateEmptyCalculatedColumn: typeof CreateEmptyCalculatedColumn;
@@ -88,16 +75,7 @@ export declare const ObjectFactory: {
     CreateEmptyFlashingCellDefinition: typeof CreateEmptyFlashingCellDefinition;
     CreateInternalAlertDefinitionForMessages: typeof CreateInternalAlertDefinitionForMessages;
     CreateEmptyReport: typeof CreateEmptyReport;
-    CreateEmptyBaseSchedule: typeof CreateEmptyBaseSchedule;
-    CreateEmptyReminderSchedule: typeof CreateEmptyReminderSchedule;
     CreateEmptyReportSchedule: typeof CreateEmptyReportSchedule;
-    CreateEmptyIPushPullSchedule: typeof CreateEmptyIPushPullSchedule;
-    CreateEmptyIPushPullReport: typeof CreateEmptyIPushPullReport;
-    CreateIPushPullSchedule: typeof CreateIPushPullSchedule;
-    CreateReportSchedule: typeof CreateReportSchedule;
-    CreateEmptyOpenFinReport: typeof CreateEmptyOpenFinReport;
-    CreateEmptyOpenFinSchedule: typeof CreateEmptyOpenFinSchedule;
-    CreateEmptySchedule: typeof CreateEmptySchedule;
     CreateEmptyShortcut: typeof CreateEmptyShortcut;
     CreateEmptyFormatColumn: typeof CreateEmptyFormatColumn;
     CreateEmptyFreeTextColumn: typeof CreateEmptyFreeTextColumn;
@@ -116,5 +94,6 @@ export declare const ObjectFactory: {
     CreateEmptyTheme: typeof CreateEmptyTheme;
     CreateEmptyCommentThread: typeof CreateEmptyCommentThread;
     CreateAdaptableComment: typeof CreateAdaptableComment;
+    CreateDefaultSchedule: typeof CreateDefaultSchedule;
 };
 export default ObjectFactory;

package/src/Utilities/ObjectFactory.js

@@ -1,9 +1,10 @@
-import { MathOperation, ScheduleType } from '../AdaptableState/Common/Enums';
+import { MathOperation, } from '../AdaptableState/Common/Enums';
 import { createUuid } from '../AdaptableState/Uuid';
+import { buildCronExpression } from './Helpers/ScheduleHelper';
 import { EMPTY_STRING } from './Constants/GeneralConstants';
 import { ALERT_DEFAULT_MESSAGE_TYPE, ALERT_DEFAULT_SHOW_POPUP, PLUS_MINUS_DEFAULT_NUDGE_VALUE, } from './Constants/ObjectDefaultConstants';
 import { Bounce, Flip, Slide, Zoom } from '../components/Toastify';
-import { BLACK, getHexForName, LIGHT_GRAY } from '../View/UIHelper';
+import { getSwatchColorVar } from '../View/UIHelper';
 import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
 export function CreateEmptyCustomSort() {
     return { Uuid: createUuid(), Name: EMPTY_STRING, ColumnId: EMPTY_STRING, SortedValues: [] };
@@ -130,100 +131,16 @@ export function CreateEmptyReport() {
         Query: undefined,
     };
 }
-export function CreateEmptyBaseSchedule(scheduleType) {
+export function CreateEmptyReportSchedule(reportFormat, reportName) {
     return {
         Uuid: createUuid(),
         Name: EMPTY_STRING,
-        ScheduleType: scheduleType,
-        Schedule: CreateEmptySchedule(),
-    };
-}
-export function CreateEmptyReminderSchedule() {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.Reminder,
-        Schedule: CreateEmptySchedule(),
-        Header: EMPTY_STRING,
-        Message: EMPTY_STRING,
-        MessageType: 'Info',
-        DisplayNotification: true,
-        DisplaySystemStatusMessage: false,
-    };
-}
-export function CreateEmptyReportSchedule() {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.Report,
-        Schedule: CreateEmptySchedule(),
-        ReportName: EMPTY_STRING,
-        ReportFormat: EMPTY_STRING,
+        ReportName: reportName ?? EMPTY_STRING,
+        Schedule: CreateDefaultSchedule(),
+        ReportFormat: reportFormat ?? EMPTY_STRING,
         ExportDestination: 'Download',
     };
 }
-export function CreateEmptyIPushPullReport() {
-    return {
-        Uuid: createUuid(),
-        ReportName: EMPTY_STRING,
-        Folder: EMPTY_STRING,
-        Page: EMPTY_STRING,
-    };
-}
-export function CreateEmptyOpenFinReport() {
-    return {
-        Uuid: createUuid(),
-        ReportName: EMPTY_STRING,
-    };
-}
-export function CreateEmptyIPushPullSchedule() {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.ipushpull,
-        Schedule: CreateEmptySchedule(),
-        IPushPullReport: CreateEmptyIPushPullReport(),
-        Transmission: 'Snapshot',
-    };
-}
-export function CreateEmptyOpenFinSchedule() {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.OpenFin,
-        Schedule: CreateEmptySchedule(),
-        OpenFinReport: CreateEmptyOpenFinReport(),
-        Transmission: 'Live Data',
-    };
-}
-export function CreateIPushPullSchedule(iPushPullReport) {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.ipushpull,
-        Schedule: CreateEmptySchedule(),
-        IPushPullReport: iPushPullReport,
-        Transmission: 'Snapshot',
-    };
-}
-export function CreateReportSchedule(reportName, reportFormat) {
-    return {
-        Uuid: createUuid(),
-        Name: EMPTY_STRING,
-        ScheduleType: ScheduleType.Report,
-        Schedule: CreateEmptySchedule(),
-        ReportName: reportName,
-        ReportFormat: reportFormat,
-    };
-}
-export function CreateEmptySchedule() {
-    return {
-        OneOffDate: undefined,
-        DaysOfWeek: [],
-        Hour: 0,
-        Minute: 0,
-    };
-}
 export function CreateEmptyShortcut() {
     return {
         Uuid: createUuid(),
@@ -344,15 +261,16 @@ export function CreateColumnFilter(ColumnId, PredicateId, Inputs) {
 export function CreateEmptyStyledColumn() {
     return {
         Uuid: createUuid(),
+        Name: EMPTY_STRING,
         ColumnId: EMPTY_STRING,
     };
 }
 export function CreateDefaultStyledColumnBadge() {
     return {
-        Style: {
-            BackColor: getHexForName(LIGHT_GRAY),
-            ForeColor: getHexForName(BLACK),
-            BorderRadius: 6,
+        Shape: 'Rounded',
+        PillStyle: {
+            BackColor: getSwatchColorVar(3), // light gray by default (for styled column badge)
+            ForeColor: getSwatchColorVar(1), // black by default (for styled column badge)
         },
     };
 }
@@ -437,6 +355,12 @@ export function CreateToastOptions(notificationsOptions, { onClose, containerId
     };
     return toastProps;
 }
+export function CreateDefaultSchedule() {
+    return {
+        IsOneOff: false,
+        CronExpression: buildCronExpression('weekdays', 9, 0),
+    };
+}
 export const ObjectFactory = {
     CreateEmptyCustomSort,
     CreateEmptyCalculatedColumn,
@@ -449,16 +373,7 @@ export const ObjectFactory = {
     CreateEmptyFlashingCellDefinition,
     CreateInternalAlertDefinitionForMessages,
     CreateEmptyReport,
-    CreateEmptyBaseSchedule,
-    CreateEmptyReminderSchedule,
     CreateEmptyReportSchedule,
-    CreateEmptyIPushPullSchedule,
-    CreateEmptyIPushPullReport,
-    CreateIPushPullSchedule,
-    CreateReportSchedule,
-    CreateEmptyOpenFinReport,
-    CreateEmptyOpenFinSchedule,
-    CreateEmptySchedule,
     CreateEmptyShortcut,
     CreateEmptyFormatColumn,
     CreateEmptyFreeTextColumn,
@@ -477,5 +392,6 @@ export const ObjectFactory = {
     CreateEmptyTheme,
     CreateEmptyCommentThread,
     CreateAdaptableComment,
+    CreateDefaultSchedule,
 };
 export default ObjectFactory;

package/src/Utilities/Services/AlertService.js

@@ -23,6 +23,9 @@ export class AlertService {
     createReactiveAlert(alertDefinition) {
         // if there is already a reactive alert for this definition, delete it (possible in case of editing definitions),
         this.deleteReactiveAlert(alertDefinition);
+        if (!('Rule' in alertDefinition)) {
+            return;
+        }
         if (!alertDefinition.Rule.ObservableExpression) {
             return;
         }

package/src/Utilities/Services/ModuleService.js

@@ -155,8 +155,6 @@ export class ModuleService {
                 return url + 'handbook-editing-plus-minus';
             case 'QuickSearch':
                 return url + 'handbook-quick-search';
-            case 'Schedule':
-                return url + 'handbook-scheduling';
             case 'SettingsPanel':
                 return url + 'ui-settings-panel';
             case 'Shortcut':

package/src/Utilities/Services/QueryLanguageService.js

@@ -269,7 +269,7 @@ export class QueryLanguageService {
             result = result.split(columnId).join(columnFriendlyName);
         });
         // replace $SCOPE() with friendly name as well
-        result = result.split(`$SCOPE()`).join(`"<Column Scope>"`);
+        result = result.split(`$SCOPE()`).join(`$Column_Scope`);
         return result;
     }
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`