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

package/src/Api/AlertApi.d.ts

@@ -1,6 +1,6 @@
-import { AlertDefinition, AlertState } from '../AdaptableState/AlertState';
+import { AlertDefinition, AlertPresentationProperties, AlertState } from '../AdaptableState/AlertState';
 import { AdaptableAlert } from '../AdaptableState/Common/AdaptableAlert';
-import { AdaptableMessageType, AlertProperties, LayoutExtendedConfig } from '../types';
+import { AdaptableMessageType, LayoutExtendedConfig } from '../types';
 import { AdaptableObjectLookupCriteria } from '../AdaptableState/Common/AdaptableObject';
 /**
  * Provides run-time access to Alert function and associated State
@@ -102,7 +102,7 @@ export interface AlertApi {
      * @param alertHeader Header of the Alert (if shown in a popup its the Title of the Window)
      * @param alertMessage Main message of the alert
      */
-    showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertProperties): Promise<void>;
+    showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertPresentationProperties): Promise<void>;
     /**
      * Creates an Adaptable Alert based on given parameters and displays it as Info Alert.
      * @param alertHeader Header of the Alert (if shown in a popup its the Title of the Window)
@@ -127,4 +127,8 @@ export interface AlertApi {
      * @param alertMessage Main message of the alert
      */
     showAlertError(alertHeader: string, alertMessage: string): Promise<void>;
+    /**
+     * Fires a scheduled alert definition (notification, system status, etc.)
+     */
+    applyScheduledAlertDefinition(alertDefinition: AlertDefinition): void;
 }

package/src/Api/ChartingApi.d.ts

@@ -65,7 +65,7 @@ export interface ChartingApi {
      * @param chartDefinition Chart to show
      * @param container Container in which to display the Chart
      */
-    showChartDefinitionOnce(chartDefinition: ChartDefinition, container?: HTMLElement): ChartRef;
+    showChartDefinitionOnce(chartDefinition: ChartDefinition, container?: HTMLElement | string): ChartRef | undefined;
     /**
      * Edit existing Chart
      * @param chartDefinition Chart to edit

package/src/Api/ColumnFilterApi.d.ts

@@ -18,6 +18,10 @@ export interface ColumnFilterApi {
      * Makes Quick Filter Bar appear
      */
     showQuickFilterBar(): void;
+    /**
+     * Hides Column Filter Menu
+     */
+    hideColumnFilterMenu(): void;
     /**
      * Hides Quick Filter bar
      */

package/src/Api/ColumnMenuApi.d.ts

@@ -10,7 +10,7 @@ export interface ColumnMenuApi {
     /**
      * Hide the Column Menu
      */
-    hideColumnMenu(columnKey: string): void;
+    hideColumnMenu(): void;
     /**
      * Creates default menu structure; useful as final line in custom implementation
      * @param context Current Menu Context

package/src/Api/ColumnScopeApi.d.ts

@@ -142,8 +142,12 @@ export interface ColumnScopeApi {
      */
     getScopeDescription(scope: ColumnScope): string;
     /**
-     * Creates Cell Color Ranges (used in Format Column) for given Scope
-     * @param scope Scope to use
+     * Creates a default single `CellColorRange` for Styled Column wizards (Gradient,
+     * Percent Bar, Bullet Chart): `Col-Min` → `Col-Max` with neutral gray, matching
+     * the colour used when adding a range in the Ranges UI. If the column has no
+     * sample values yet, returns one `0` → `0` gray range.
+     *
+     * @param scope Scope to use (must resolve to a single column for range sampling)
      */
     createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
     /**

package/src/Api/DashboardApi.d.ts

@@ -50,6 +50,19 @@ export interface DashboardApi {
      * @param customToolbarName the name of the Custom Toolbar
      */
     getCustomToolbarByName(customToolbarName: string): CustomToolbar;
+    /**
+     * Resets the data of a Custom Toolbar's `toolbarForm` back to the
+     * `defaultValue`s declared on its fields - clearing any user input
+     * without unmounting / re-mounting the toolbar.
+     *
+     * Useful for "Clear filters" buttons that need to wipe both the grid
+     * filter AND the toolbar form's internal state in a single click.
+     *
+     * @param customToolbarName Name of the Custom Toolbar to reset. If
+     * omitted, every Custom Toolbar that currently hosts a `toolbarForm`
+     * is reset.
+     */
+    resetCustomToolbarFormData(customToolbarName?: string): void;
     /**
      * Collapses Dashboard so only Dashboard Header is visible (and not Toolbars' contents)
      */

package/src/Api/EventApi.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableReadyInfo, AdaptableStateChangedInfo, AdaptableStateReloadedInfo, BeforeAdaptableStateChangeInfo, AlertFiredInfo, CalculatedColumnChangedInfo, CellChangedInfo, CellSelectionChangedInfo, ChartChangedInfo, ColumnFilterAppliedInfo, CommentChangedInfo, CustomToolbarConfiguredInfo, DashboardChangedInfo, DataImportedInfo, DataSetSelectedInfo, Fdc3MessageInfo, FlashingCellDisplayedInfo, GridFilterAppliedInfo, GridSortedInfo, LayoutChangedInfo, LiveDataChangedInfo, RowChangedInfo, RowFormSubmittedInfo, RowSelectionChangedInfo, ScheduleTriggeredInfo, SystemStatusMessageDisplayedInfo, TeamSharingEntityChangedInfo, ThemeChangedInfo } from '../types';
+import { AdaptableReadyInfo, AdaptableStateChangedInfo, AdaptableStateReloadedInfo, BeforeAdaptableStateChangeInfo, AlertFiredInfo, CalculatedColumnChangedInfo, CellChangedInfo, CellSelectionChangedInfo, ChartChangedInfo, ColumnFilterAppliedInfo, CommentChangedInfo, CustomToolbarConfiguredInfo, DashboardChangedInfo, DataImportedInfo, DataSetSelectedInfo, Fdc3MessageInfo, FlashingCellDisplayedInfo, GridFilterAppliedInfo, GridSortedInfo, LayoutChangedInfo, LiveDataChangedInfo, RowChangedInfo, RowFormSubmittedInfo, RowSelectionChangedInfo, ReportScheduleRanInfo, SystemStatusMessageDisplayedInfo, TeamSharingEntityChangedInfo, ThemeChangedInfo } from '../types';
 /**
  * Responsible for publishing the many Events that AdapTable fires
  */
@@ -31,17 +31,16 @@ export interface EventApi {
     off(eventName: 'GridFilterApplied', callback: (gridFilterAppliedInfo: GridFilterAppliedInfo) => void): void;
     /**
      * Event fired whenever a Schedule is triggered in AdapTable
-     * @param eventName ScheduleTriggered
-     * @param callback ScheduleTriggered which provides details of the Schedule that was triggered
-     * @returns the unsubscribe function
+     * @param eventName ReportScheduleRan
+     * @param callback ReportScheduleRan which provides details of the Report Schedule that was triggered
      */
-    on(eventName: 'ScheduleTriggered', callback: (scheduleTriggeredInfo: ScheduleTriggeredInfo) => void): VoidFunction;
+    on(eventName: 'ReportScheduleRan', callback: (reportScheduleRanInfo: ReportScheduleRanInfo) => void): VoidFunction;
     /**
-     * Unsubscribe from ScheduleTriggered
-     * @param eventName ScheduleTriggered
+     * Unsubscribe from ReportScheduleRan
+     * @param eventName ReportScheduleRan
      * @param callback
      */
-    off(eventName: 'ScheduleTriggered', callback: (scheduleTriggeredInfo: ScheduleTriggeredInfo) => void): void;
+    off(eventName: 'ReportScheduleRan', callback: (reportScheduleRanInfo: ReportScheduleRanInfo) => void): void;
     /**
      * Event fired whenever a Column Filter is Applied in AdapTable
      * @param eventName ColumnFilterApplied

package/src/Api/Events/ReportScheduleRan.d.ts

@@ -0,0 +1,11 @@
+import { ReportSchedule } from '../../AdaptableState/ExportState';
+import { BaseContext } from '../../types';
+/**
+ * EventInfo returned by the ReportScheduleRan event
+ */
+export interface ReportScheduleRanInfo extends BaseContext {
+    /**
+     * Report schedule that was triggered (if applicable)
+     */
+    reportSchedule?: ReportSchedule;
+}

package/src/Api/ExportApi.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableForm } from '../AdaptableState/Common/AdaptableForm';
-import { ExportState, Report, ReportFormatType, ReportNameType, SystemReportFormat, SystemReportName } from '../AdaptableState/ExportState';
+import { ExportState, Report, ReportFormatType, ReportNameType, ReportSchedule, SystemReportFormat, SystemReportName } from '../AdaptableState/ExportState';
+import { LayoutExtendedConfig } from '../types';
 import { CustomDestination, CustomExportParams, ExportConfig, ExportDestinationType, ExportFormContext, ExportResultData, SystemExportDestination } from '../AdaptableOptions/ExportOptions';
 import { AdaptableColumn } from '../types';
 /**
@@ -157,4 +158,44 @@ export interface ExportApi {
         exportParams?: (defaultExportParams: CustomExportParams) => CustomExportParams;
         showProgressIndicator?: boolean;
     }): Promise<ExportResultData>;
+    /**
+     * All scheduled reports (custom reports and system reports)
+     */
+    getScheduledReports(config?: LayoutExtendedConfig): ReportSchedule[];
+    /**
+     * All active scheduled reports (custom reports and system reports)
+     */
+    getActiveScheduledReports(config?: LayoutExtendedConfig): ReportSchedule[];
+    /**
+     * Retrieves a scheduled report by its Uuid
+     */
+    getScheduledReportById(reportScheduleId: ReportSchedule['Uuid'], config?: LayoutExtendedConfig): ReportSchedule | undefined;
+    /**
+     * Adds a scheduled report
+     */
+    addScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Edits a scheduled report
+     */
+    editScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Deletes a scheduled report
+     */
+    deleteScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Suspends a scheduled report
+     */
+    suspendScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Unsuspends a scheduled report
+     */
+    unSuspendScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Runs a scheduled export and records the job-run action
+     */
+    applyScheduledReport(reportSchedule: ReportSchedule): void;
+    /**
+     * Ensures every scheduled report has a unique Uuid (legacy state may omit them).
+     */
+    ensureScheduledReportUuids(): void;
 }

package/src/Api/GridApi.d.ts

@@ -81,8 +81,8 @@ export interface GridApi {
         removedRows: IRowNode[];
     }>;
     /**
-     * Updates cell in AdapTable (first performs Cell & Server Validation)
-     * @param cellUpdateRequest (contains columnId, newValue and primaryKeyValue
+     * Updates cell in AdapTable (as an AG Grid edit)
+     * @param cellUpdateRequest (contains colId, newValue and primaryKeyValue and rowNode)
      *
      */
     setCellValue(cellUpdateRequest: CellUpdateRequest): void;

package/src/Api/GridFilterApi.d.ts

@@ -19,9 +19,16 @@ export interface GridFilterApi {
     getCurrentGridFilterExpression(): string | undefined;
     /**
      * Sets the Grid Filter (for the current layout)
-     * @param expression filter string
-     */
-    setGridFilterExpression(expression: string): void;
+     *
+     * If `expression` is `null`, `undefined` or a blank string the Grid Filter
+     * is cleared (equivalent to calling {@link clearGridFilter}). This makes
+     * it safe to drive the Grid Filter from form-style controls that emit
+     * empty values when the user deselects everything, without having to
+     * branch in the caller.
+     *
+     * @param expression filter string, or a falsy value to clear the filter
+     */
+    setGridFilterExpression(expression: string | null | undefined): void;
     /**
      * Sets the Grid Filter (for the current layout)
      * @param namedQuery: NamedQuery to use

package/src/Api/IPushPullApi.d.ts

@@ -1,5 +1,5 @@
 import { IPushPullReport } from '../AdaptableState/InternalState';
-import { IPushPullDomain, IPushPullSchedule } from '../AdaptableState/IPushPullState';
+import { IPushPullDomain } from '../AdaptableState/IPushPullState';
 /**
  * Provides run-time access to ipushpull Plugin
  */
@@ -123,10 +123,6 @@ export interface IPushPullApi {
      * Logs out the current user from ipushpull (changes ipushpull toolbar to show Login button)
      */
     logoutFromIPushPull(): void;
-    /**
-     * Gets ipushpull schedules ie. reports set to run at particular times
-     */
-    getIPushPullSchedules(): IPushPullSchedule[];
     /**
      * Checks if an ipushpull instance has been provided by the user
      */

package/src/Api/Implementation/AdaptableApiImpl.d.ts

@@ -26,7 +26,6 @@ import { SystemStatusApi } from '../SystemStatusApi';
 import { UserInterfaceApi } from '../UserInterfaceApi';
 import { ThemeApi } from '../ThemeApi';
 import { GridApi } from '../GridApi';
-import { ScheduleApi } from '../ScheduleApi';
 import { ExpressionApi } from '../ExpressionApi';
 import { TeamSharingApi } from '../TeamSharingApi';
 import { ColumnApi } from '../ColumnApi';
@@ -71,7 +70,6 @@ export declare class AdaptableApiImpl implements AdaptableApi {
     plusMinusApi: PlusMinusApi;
     quickSearchApi: QuickSearchApi;
     rowFormApi: RowFormApi;
-    scheduleApi: ScheduleApi;
     shortcutApi: ShortcutApi;
     smartEditApi: SmartEditApi;
     filterApi: FilterApi;

package/src/Api/Implementation/AdaptableApiImpl.js

@@ -24,7 +24,6 @@ import { SystemStatusApiImpl } from './SystemStatusApiImpl';
 import { ThemeApiImpl } from './ThemeApiImpl';
 import { UserInterfaceApiImpl } from './UserInterfaceApiImpl';
 import { AdaptableInternalApi } from '../Internal/AdaptableInternalApi';
-import { ScheduleApiImpl } from './ScheduleApiImpl';
 import { TeamSharingApiImpl } from './TeamSharingApiImpl';
 import { ColumnApiImpl } from './ColumnApiImpl';
 import { ApplicationApiImpl } from './ApplicationApiImpl';
@@ -76,7 +75,6 @@ export class AdaptableApiImpl {
     plusMinusApi;
     quickSearchApi;
     rowFormApi;
-    scheduleApi;
     shortcutApi;
     smartEditApi;
     filterApi;
@@ -133,7 +131,6 @@ export class AdaptableApiImpl {
         this.plusMinusApi = new PlusMinusApiImpl(adaptable);
         this.quickSearchApi = new QuickSearchApiImpl(adaptable);
         this.rowFormApi = new RowFormApiImpl(adaptable);
-        this.scheduleApi = new ScheduleApiImpl(adaptable);
         this.shortcutApi = new ShortcutApiImpl(adaptable);
         this.smartEditApi = new SmartEditApiImpl(adaptable);
         this.systemStatusApi = new SystemStatusApiImpl(adaptable);
@@ -201,7 +198,6 @@ export class AdaptableApiImpl {
         this.predicateApi = null;
         this.expressionApi = null;
         this.quickSearchApi = null;
-        this.scheduleApi = null;
         this.columnScopeApi = null;
         this.settingsPanelApi = null;
         this.shortcutApi = null;

package/src/Api/Implementation/AlertApiImpl.d.ts

@@ -1,6 +1,6 @@
 import { ApiBase } from './ApiBase';
 import { AlertApi } from '../AlertApi';
-import { AlertDefinition, AlertProperties, AlertState } from '../../AdaptableState/AlertState';
+import { AlertDefinition, AlertPresentationProperties, AlertState } from '../../AdaptableState/AlertState';
 import { AdaptableAlert } from '../../AdaptableState/Common/AdaptableAlert';
 import { AdaptableMessageType } from '../../AdaptableState/Common/AdaptableMessageType';
 import { AdaptableObjectLookupCriteria } from '../../AdaptableState/Common/AdaptableObject';
@@ -20,11 +20,12 @@ export declare class AlertApiImpl extends ApiBase implements AlertApi {
     addAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
     displayAdaptableAlert(alertToShow: AdaptableAlert): Promise<void>;
     displayAdaptableAlertNotification(alert: AdaptableAlert): void;
-    showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertProperties): Promise<void>;
-    showAlertInfo(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
-    showAlertSuccess(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
-    showAlertWarning(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
-    showAlertError(alertHeader: string, alertMessage: string, alertProperties?: AlertProperties): Promise<void>;
+    showAlert(alertHeader: string, alertMessage: string, messageType: AdaptableMessageType, alertProperties?: AlertPresentationProperties): Promise<void>;
+    showAlertInfo(alertHeader: string, alertMessage: string, alertProperties?: AlertPresentationProperties): Promise<void>;
+    showAlertSuccess(alertHeader: string, alertMessage: string, alertProperties?: AlertPresentationProperties): Promise<void>;
+    showAlertWarning(alertHeader: string, alertMessage: string, alertProperties?: AlertPresentationProperties): Promise<void>;
+    applyScheduledAlertDefinition(alertDefinition: AlertDefinition): void;
+    showAlertError(alertHeader: string, alertMessage: string, alertProperties?: AlertPresentationProperties): Promise<void>;
     openAlertSettingsPanel(): void;
     editAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;
     suspendAlertDefinition(alertDefinition: AlertDefinition): AlertDefinition;

package/src/Api/Implementation/AlertApiImpl.js

@@ -8,6 +8,7 @@ import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { AlertInternalApi } from '../Internal/AlertInternalApi';
 import { resolveContainerElement } from '../../Utilities/resolveContainerElement';
+import { isRuleBasedAlertDefinition } from '../../Utilities/Helpers/ScheduledAlertHelper';
 export class AlertApiImpl extends ApiBase {
     internalApi;
     constructor(_adaptable) {
@@ -50,25 +51,32 @@ export class AlertApiImpl extends ApiBase {
         this.getEventApi().internalApi.fireAlertFiredEvent(alertToShow);
         // 3. Manage the many different possible Alert behaviours
         // Note:  alertProperties.PreventEdit is handled separately, in the Adaptable.setupColumnValueSetter() function
-        if (alertToShow.alertDefinition && alertToShow.alertDefinition.AlertProperties != undefined) {
+        if (alertToShow.alertDefinition?.AlertProperties != undefined) {
             const alertDefinition = alertToShow.alertDefinition;
-            const alertProperties = alertDefinition.AlertProperties;
+            const presentationProperties = alertDefinition.AlertProperties;
             // Show a Toast Popup
-            if (alertProperties.DisplayNotification) {
+            if (presentationProperties.DisplayNotification) {
                 this.displayAdaptableAlertNotification(alertToShow);
             }
             // Log to console
-            if (alertProperties.LogToConsole) {
+            if (presentationProperties.LogToConsole) {
                 this.getAdatableLogger().consoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
             }
+            if (presentationProperties.DisplaySystemStatusMessage) {
+                this.getSystemStatusApi().setSystemStatus(alertToShow.header, alertDefinition.MessageType, alertToShow.message);
+            }
             // Show Alert in a Div (if one has been set)
-            if (alertProperties.ShowInDiv) {
+            if (presentationProperties.ShowInDiv) {
                 const alertDiv = resolveContainerElement(this.getContainerOptions().alertContainer, this.getAdaptableInternalApi().buildBaseContext());
                 if (alertDiv) {
                     let alertString = alertToShow.header + ': ' + alertToShow.message;
                     alertDiv.innerHTML = alertString;
                 }
             }
+            if (!isRuleBasedAlertDefinition(alertDefinition)) {
+                return;
+            }
+            const alertProperties = alertDefinition.AlertProperties ?? {};
             // Jump to the Cell
             if (alertProperties.JumpToCell &&
                 isAdaptableCellChangedAlert(alertToShow) &&
@@ -136,6 +144,12 @@ export class AlertApiImpl extends ApiBase {
     async showAlertWarning(alertHeader, alertMessage, alertProperties) {
         await this.showAlert(alertHeader, alertMessage, 'Warning', alertProperties);
     }
+    applyScheduledAlertDefinition(alertDefinition) {
+        const header = alertDefinition.MessageHeader ?? alertDefinition.Name;
+        const message = alertDefinition.MessageText ?? '';
+        const alertToShow = ObjectFactory.CreateGenericAlert(header, message, alertDefinition);
+        this.displayAdaptableAlert(alertToShow);
+    }
     async showAlertError(alertHeader, alertMessage, alertProperties) {
         await this.showAlert(alertHeader, alertMessage, 'Error', alertProperties);
     }
@@ -162,6 +176,9 @@ export class AlertApiImpl extends ApiBase {
     }
     evaluateAlertDefinitions(alertDefinitions) {
         const filterScopeAllDefinitions = (alertDefinition) => {
+            if (!isRuleBasedAlertDefinition(alertDefinition)) {
+                return false;
+            }
             if (this.getColumnScopeApi().scopeIsAll(alertDefinition.Scope) &&
                 !this.getExpressionApi().getAdaptableQueryExpression(alertDefinition.Rule)) {
                 // we don't support scope ALL without an expression
@@ -192,9 +209,12 @@ export class AlertApiImpl extends ApiBase {
         const config = {
             includeLayoutNotExtendedObjects: true,
         };
-        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions(config));
+        return this.getAdaptableInternalApi().findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions(config).filter(isRuleBasedAlertDefinition));
     }
     getRelevantColumnIdsForAlertDefinition(alertDefinition) {
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return [];
+        }
         //  if there is an Expression defined, extract only the columns from there (in that case the Scope would be 'All' anyway)
         // columns referenced in rule expression
         const ruleExpression = this.getExpressionApi().getAdaptableQueryExpression(alertDefinition.Rule);

package/src/Api/Implementation/ApiBase.d.ts

@@ -8,7 +8,7 @@ import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
 import { GridApi as AgGridApi } from 'ag-grid-enterprise';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
-import { ActionColumnApi, ActionColumnOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, FilterApi, ColumnOptions, CommentOptions, StateApi, ContainerOptions, CustomSortApi, CustomSortOptions, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataChangeHistoryOptions, DataSetApi, DataSetOptions, EditOptions, EntitlementApi, EntitlementOptions, EventApi, ExportApi, ExpressionApi, ExpressionOptions, Fdc3Api, Fdc3Options, FlashingCellApi, FlashingCellOptions, FormatColumnApi, FormatColumnOptions, FreeTextColumnApi, GridApi, GridFilterApi, LayoutApi, LayoutExtensionObject, LayoutOptions, NamedQueryApi, NoteOptions, NotificationsOptions, PluginsApi, PlusMinusApi, PredicateApi, PredicateOptions, QuickSearchApi, QuickSearchOptions, ScheduleApi, ColumnScopeApi, SettingsPanelApi, SettingsPanelOptions, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, ToolPanelOptions, UserInterfaceApi, UserInterfaceOptions, ColumnMenuOptions, ContextMenuOptions, FilterOptions, ColumnFilterApi, OptionsApi, LayoutExtensionModule, LayoutExtendedConfig } from '../../types';
+import { ActionColumnApi, ActionColumnOptions, AlertApi, AlertOptions, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CalendarOptions, CellSummaryApi, CellSummaryOptions, ChartingApi, ChartingOptions, ColumnApi, FilterApi, ColumnOptions, CommentOptions, StateApi, ContainerOptions, CustomSortApi, CustomSortOptions, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataChangeHistoryOptions, DataSetApi, DataSetOptions, EditOptions, EntitlementApi, EntitlementOptions, EventApi, ExportApi, ExpressionApi, ExpressionOptions, Fdc3Api, Fdc3Options, FlashingCellApi, FlashingCellOptions, FormatColumnApi, FormatColumnOptions, FreeTextColumnApi, GridApi, GridFilterApi, LayoutApi, LayoutExtensionObject, LayoutOptions, NamedQueryApi, NoteOptions, NotificationsOptions, PluginsApi, PlusMinusApi, PredicateApi, PredicateOptions, QuickSearchApi, QuickSearchOptions, ColumnScopeApi, SettingsPanelApi, SettingsPanelOptions, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, ToolPanelOptions, UserInterfaceApi, UserInterfaceOptions, ColumnMenuOptions, ContextMenuOptions, FilterOptions, ColumnFilterApi, OptionsApi, LayoutExtensionModule, LayoutExtendedConfig } from '../../types';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
 import { AdaptableInternalApi } from '../Internal/AdaptableInternalApi';
 import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
@@ -119,7 +119,6 @@ export declare abstract class ApiBase {
     protected getRowFormApi(): RowFormApi;
     protected getPlusMinusApi(): PlusMinusApi;
     protected getQuickSearchApi(): QuickSearchApi;
-    protected getScheduleApi(): ScheduleApi;
     protected getShortcutApi(): ShortcutApi;
     protected getSmartEditApi(): SmartEditApi;
     protected getSystemStatusApi(): SystemStatusApi;

package/src/Api/Implementation/ApiBase.js

@@ -291,9 +291,6 @@ export class ApiBase {
     getQuickSearchApi() {
         return this.getAdaptableApi().quickSearchApi;
     }
-    getScheduleApi() {
-        return this.getAdaptableApi().scheduleApi;
-    }
     getShortcutApi() {
         return this.getAdaptableApi().shortcutApi;
     }

package/src/Api/Implementation/ChartingApiImpl.d.ts

@@ -16,7 +16,7 @@ export declare class ChartingApiImpl extends ApiBase implements ChartingApi {
     getChartDefinitionByName(name: string): ChartDefinition | undefined;
     showPersistedCharts(): ChartRef[];
     showChartDefinition(chartDefiniton: ChartDefinition, container?: HTMLElement | string): ChartRef;
-    showChartDefinitionOnce(chartDefinition: ChartDefinition, container?: HTMLElement): ChartRef;
+    showChartDefinitionOnce(chartDefinition: ChartDefinition, container?: HTMLElement | string): ChartRef | undefined;
     closeChartDefinition(chartDefinition: ChartDefinition): void;
     editChartDefinition(editedChartDefinition: ChartDefinition): void;
     updateAgChart(chartDefinition: ChartDefinition): void;

package/src/Api/Implementation/ChartingApiImpl.js

@@ -4,6 +4,7 @@ import { ChartingGetChartModels } from './../../Redux/ActionsReducers/ChartingRe
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { ChartingInternalApi } from '../Internal/ChartingInternalApi';
 import ObjectFactory from '../../Utilities/ObjectFactory';
+import { validateChartName } from '../../Utilities/Helpers/chartingHelper';
 export class ChartingApiImpl extends ApiBase {
     /**
      * @internal
@@ -60,7 +61,7 @@ export class ChartingApiImpl extends ApiBase {
     showChartDefinitionOnce(chartDefinition, container) {
         const chartRef = this.getChartRef(chartDefinition?.Model?.chartId);
         if (chartRef) {
-            return;
+            return chartRef;
         }
         return this.showChartDefinition(chartDefinition, container);
     }
@@ -71,6 +72,11 @@ export class ChartingApiImpl extends ApiBase {
         }
     }
     editChartDefinition(editedChartDefinition) {
+        const nameValidation = validateChartName(this.getAdaptableApi(), editedChartDefinition.Name, editedChartDefinition.Uuid);
+        if (nameValidation !== true) {
+            this.getAdatableLogger().consoleLogByMessageType(nameValidation, 'Warning');
+            return;
+        }
         this.dispatchAction(ChartingRedux.ChartingEditChart(editedChartDefinition));
         this.updateAgChart(editedChartDefinition);
     }
@@ -78,6 +84,11 @@ export class ChartingApiImpl extends ApiBase {
         this._adaptable.updateChart(chartDefinition);
     }
     addChartDefinition(chart) {
+        const nameValidation = validateChartName(this.getAdaptableApi(), chart.Name, chart.Uuid);
+        if (nameValidation !== true) {
+            this.getAdatableLogger().consoleLogByMessageType(nameValidation, 'Warning');
+            return;
+        }
         this.dispatchAction(ChartingRedux.ChartingAddChart(chart));
     }
     getChartingOpenState() {
@@ -113,10 +124,16 @@ export class ChartingApiImpl extends ApiBase {
     }
     addExternalChartDefinition(chartDefinition, options) {
         const saveChartBehaviour = options?.saveChartBehaviour ?? 'manual';
+        const chartName = chartDefinition.Name?.trim() || this.internalApi.getUniqueChartName();
         if (saveChartBehaviour === 'auto') {
+            const nameValidation = validateChartName(this.getAdaptableApi(), chartName, chartDefinition.Uuid);
+            if (nameValidation !== true) {
+                this.getAdatableLogger().consoleLogByMessageType(nameValidation, 'Warning');
+                return;
+            }
             this.dispatchAction(ChartingRedux.ChartingAddExternalChart({
                 ...chartDefinition,
-                Name: chartDefinition.Name ?? this.internalApi.getUniqueChartName(),
+                Name: chartName,
             }));
         }
         else {
@@ -169,6 +186,11 @@ export class ChartingApiImpl extends ApiBase {
         }
     }
     editExternalChartDefinition(chartDefinition) {
+        const nameValidation = validateChartName(this.getAdaptableApi(), chartDefinition.Name, chartDefinition.Uuid);
+        if (nameValidation !== true) {
+            this.getAdatableLogger().consoleLogByMessageType(nameValidation, 'Warning');
+            return;
+        }
         this.dispatchAction(ChartingRedux.ChartingEditExternalChart(chartDefinition));
     }
     deleteExternalChartDefinition(chartDefinition) {

package/src/Api/Implementation/ColumnFilterApiImpl.d.ts

@@ -8,6 +8,7 @@ import { ColumnFilterApi } from '../ColumnFilterApi';
 export declare class ColumnFilterApiImpl extends ApiBase implements ColumnFilterApi {
     internalApi: ColumnFilterInternalApi;
     constructor(_adaptable: IAdaptable);
+    hideColumnFilterMenu(): void;
     getFilterPredicateDefsForColumn(column: AdaptableColumn): AdaptablePredicateDef[];
     getFilterPredicateDefsForColumnId(columnId: string): AdaptablePredicateDef[] | undefined;
     showQuickFilterBar(): void;

package/src/Api/Implementation/ColumnFilterApiImpl.js

@@ -10,6 +10,9 @@ export class ColumnFilterApiImpl extends ApiBase {
         super(_adaptable);
         this.internalApi = new ColumnFilterInternalApi(_adaptable);
     }
+    hideColumnFilterMenu() {
+        this.getAgGridApi().hideColumnFilter();
+    }
     getFilterPredicateDefsForColumn(column) {
         if (!column) {
             return [];

package/src/Api/Implementation/ColumnScopeApiImpl.js

@@ -1,6 +1,6 @@
 import { ApiBase } from './ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
-import { DARK_GREEN, getHexForName, GRAY, RED } from '../../View/UIHelper';
+import { getGraySwatchColor } from '../../View/UIHelper';
 export class ColumnScopeApiImpl extends ApiBase {
     isColumnInScope(column, scope) {
         if (!column) {
@@ -279,32 +279,26 @@ export class ColumnScopeApiImpl extends ApiBase {
         return false;
     }
     createCellColorRangesForScope(scope) {
-        let distinctColumnsValues = this.getGridApi().internalApi.getDistinctRawValuesForColumn(this.getSingleColumnInScope(scope));
-        let minValue = Math.min(...distinctColumnsValues);
-        let maxValue = Math.max(...distinctColumnsValues);
-        const ranges = [];
+        const distinctColumnsValues = this.getGridApi().internalApi.getDistinctRawValuesForColumn(this.getSingleColumnInScope(scope));
+        // One neutral band by default — same gray as RangesComponent "Add New Range".
+        // Users who want a diverging negative/positive scale should use Zero Centred
+        // (Gradient) or add/split ranges manually.
         if (this.distinctColumnValuesAreEmpty(distinctColumnsValues)) {
-            ranges.push({
-                Min: 0,
-                Max: 0,
-                Color: getHexForName(GRAY),
-            });
-        }
-        if (minValue < 0) {
-            ranges.push({
-                Min: minValue,
-                Max: 0,
-                Color: getHexForName(RED),
-            });
-        }
-        if (maxValue > 0) {
-            ranges.push({
-                Min: 0,
-                Max: maxValue,
-                Color: getHexForName(DARK_GREEN),
-            });
-        }
-        return ranges;
+            return [
+                {
+                    Min: 0,
+                    Max: 0,
+                    Color: getGraySwatchColor(),
+                },
+            ];
+        }
+        return [
+            {
+                Min: 'Col-Min',
+                Max: 'Col-Max',
+                Color: getGraySwatchColor(),
+            },
+        ];
     }
     getAnyColumnIdForScope(scope) {
         if (!scope) {

package/src/Api/Implementation/DashboardApiImpl.d.ts

@@ -22,6 +22,7 @@ export declare class DashboardApiImpl extends ApiBase implements DashboardApi {
     collapseDashboard(): void;
     expandDashboard(): void;
     refreshDashboard(): void;
+    resetCustomToolbarFormData(customToolbarName?: string): void;
     floatDashboard(): void;
     dockDashboard(): void;
     hideDashboard(): void;

package/src/Api/Implementation/DashboardApiImpl.js

@@ -1,7 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import * as DashboardRedux from '../../Redux/ActionsReducers/DashboardRedux';
 import { ApiBase } from './ApiBase';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
-import * as React from 'react';
 import { DashboardRefresh } from '../../Redux/ActionsReducers/InternalRedux';
 import { DashboardInternalApi } from '../Internal/DashboardInternalApi';
 export class DashboardApiImpl extends ApiBase {
@@ -55,7 +55,7 @@ export class DashboardApiImpl extends ApiBase {
     setCustomToolbarHTMLContent(customToolbarName, htmlContent) {
         let customRenderedContainer = this.getCustomToolbarHTMLElement(customToolbarName);
         if (customRenderedContainer) {
-            this._adaptable.renderReactRoot(React.createElement("div", { dangerouslySetInnerHTML: { __html: htmlContent } }), customRenderedContainer);
+            this._adaptable.renderReactRoot(_jsx("div", { dangerouslySetInnerHTML: { __html: htmlContent } }), customRenderedContainer);
         }
     }
     getCustomToolbarByName(customToolbarName) {
@@ -73,6 +73,9 @@ export class DashboardApiImpl extends ApiBase {
     refreshDashboard() {
         this.dispatchAction(DashboardRefresh());
     }
+    resetCustomToolbarFormData(customToolbarName) {
+        this.internalApi.resetCustomToolbarFormData(customToolbarName);
+    }
     floatDashboard() {
         this.dispatchAction(DashboardRedux.DashboardSetIsFloating(true));
     }