@adaptabletools/adaptable 22.1.1 → 23.0.0-canary.1

package/src/Api/Internal/AlertInternalApi.js

@@ -5,6 +5,7 @@ import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { AlertModuleId } from '../../Utilities/Constants/ModuleConstants';
 import { isCellDataChangedInfo } from '../../Utilities/Services/Interface/IAlertService';
 import ObjectFactory from '../../Utilities/ObjectFactory';
+import { isRuleBasedAlertDefinition, getRuleAlertProperties, } from '../../Utilities/Helpers/ScheduledAlertHelper';
 import Helper from '../../Utilities/Helpers/Helper';
 import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
@@ -37,7 +38,8 @@ export class AlertInternalApi extends ApiBase {
     getNonReactiveAlertDefinitions(config) {
         return this.getAlertApi()
             .getAlertDefinitions(config)
-            .filter((alertDef) => !isReactiveQuery(alertDef.Rule));
+            .filter((alertDef) => isRuleBasedAlertDefinition(alertDef) &&
+            !isReactiveQuery(alertDef.Rule));
     }
     /**
      * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
@@ -54,7 +56,8 @@ export class AlertInternalApi extends ApiBase {
     getReactiveAlertDefinitions(config) {
         return this.getAlertApi()
             .getAlertDefinitions(config)
-            .filter((alertDef) => isReactiveQuery(alertDef.Rule));
+            .filter((alertDef) => isRuleBasedAlertDefinition(alertDef) &&
+            isReactiveQuery(alertDef.Rule));
     }
     /**
      *
@@ -239,6 +242,9 @@ export class AlertInternalApi extends ApiBase {
                 this.logError('Error in getAlertMessageHeader', e);
             }
         }
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return alertDefinition.Name;
+        }
         let scopeDescription = this.getColumnScopeApi().getScopeDescription(alertDefinition.Scope);
         let ruleDescription = this.getAlertRuleDescription(alertDefinition);
         return scopeDescription + ' - ' + ruleDescription;
@@ -364,8 +370,11 @@ export class AlertInternalApi extends ApiBase {
      * @param alertDefinition Alert Definition to use
      */
     getAlertRuleDescription(alertDefinition) {
-        let ruleDescription = alertDefinition.Rule?.Predicates?.length
-            ? alertDefinition.Rule?.Predicates?.map((predicate) => this.getPredicateApi().predicateToString(predicate)).join(' AND ')
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return '';
+        }
+        let ruleDescription = alertDefinition.Rule.Predicates?.length
+            ? alertDefinition.Rule.Predicates.map((predicate) => this.getPredicateApi().predicateToString(predicate)).join(' AND ')
             : this.getAdaptableInternalApi().getAdaptableQueryExpressionText(alertDefinition.Rule);
         return ruleDescription;
     }
@@ -461,14 +470,14 @@ export class AlertInternalApi extends ApiBase {
     }
     getAdaptableAlertWithHighlightCell(columnId, rowNode) {
         // only alerts triggered by cell changes are relevant for HighlightCell actions
-        return this.getAdaptableCellChangedAlerts().find((alert) => alert.alertDefinition.AlertProperties?.HighlightCell &&
+        return this.getAdaptableCellChangedAlerts().find((alert) => getRuleAlertProperties(alert.alertDefinition)?.HighlightCell &&
             alert.cellDataChangedInfo?.column?.columnId === columnId &&
             alert.cellDataChangedInfo?.rowNode === rowNode);
     }
     getAdaptableAlertWithHighlightRow(rowNode) {
         let alertWithRowHighlight;
         alertWithRowHighlight = this.getAdaptableRowChangedAlerts().find((alert) => {
-            if (alert.alertDefinition.AlertProperties?.HighlightRow) {
+            if (getRuleAlertProperties(alert.alertDefinition)?.HighlightRow) {
                 if (alert.rowDataChangedInfo?.rowNodes.map((rowNode) => rowNode.id).includes(rowNode.id)) {
                     return alert;
                 }
@@ -478,7 +487,7 @@ export class AlertInternalApi extends ApiBase {
             return alertWithRowHighlight;
         }
         alertWithRowHighlight = this.getAdaptableCellChangedAlerts().find((alert) => {
-            if (alert.alertDefinition.AlertProperties?.HighlightRow) {
+            if (getRuleAlertProperties(alert.alertDefinition)?.HighlightRow) {
                 if (alert.cellDataChangedInfo?.rowNode.id == rowNode.id) {
                     return alert;
                 }
@@ -487,14 +496,20 @@ export class AlertInternalApi extends ApiBase {
         return alertWithRowHighlight;
     }
     isAlertDefinitionForAddedRowChangeEvent(alertDefinition) {
-        const observableExpression = alertDefinition?.Rule?.ObservableExpression;
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return false;
+        }
+        const observableExpression = alertDefinition.Rule.ObservableExpression;
         if (StringExtensions.IsNotNullOrEmpty(observableExpression)) {
             return observableExpression.includes(OBSERVABLE_EXPRESSION_ROW_ADDED);
         }
         return false;
     }
     isAlertDefinitionForRemovedRowChangeEvent(alertDefinition) {
-        const observableExpression = alertDefinition?.Rule?.ObservableExpression;
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return false;
+        }
+        const observableExpression = alertDefinition.Rule.ObservableExpression;
         if (StringExtensions.IsNotNullOrEmpty(observableExpression)) {
             return observableExpression.includes(OBSERVABLE_EXPRESSION_ROW_REMOVED);
         }
@@ -578,7 +593,7 @@ export class AlertInternalApi extends ApiBase {
             column: dataChangedEvent.column,
             ...this.getAdaptableInternalApi().buildBaseContext(),
         };
-        return this.getPredicateApi().handleColumnPredicates(alert.Rule?.Predicates, predicateDefHandlerContext, defaultNoPredicateReturn);
+        return this.getPredicateApi().handleColumnPredicates(alert.Rule.Predicates, predicateDefHandlerContext, defaultNoPredicateReturn);
     }
     isAlertDefinitionForRowChangeEvent(alertDefinition) {
         return (this.isAlertDefinitionForAddedRowChangeEvent(alertDefinition) ||
@@ -606,6 +621,9 @@ export class AlertInternalApi extends ApiBase {
         });
     }
     shouldFireAlertOnClient(alertDefinition) {
+        if (!isRuleBasedAlertDefinition(alertDefinition)) {
+            return true;
+        }
         const rule = alertDefinition.Rule;
         if (rule) {
             if (rule.Predicates) {

package/src/Api/Internal/ChartingInternalApi.js

@@ -1,4 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { isChartNameTaken } from '../../Utilities/Helpers/chartingHelper';
 export class ChartingInternalApi extends ApiBase {
     getContainerElement(chartContainer) {
         const element = typeof chartContainer?.element === 'string'
@@ -16,9 +17,13 @@ export class ChartingInternalApi extends ApiBase {
         return this.getContainerElement(chartContainer);
     }
     getUniqueChartName() {
-        const charts = this.getChartingApi().getChartDefinitions();
-        const externalCharts = this.getChartingApi().getExternalChartDefinitions();
-        return `Chart ${charts.length + externalCharts.length + 1}`;
+        let index = 1;
+        let candidate = `Chart ${index}`;
+        while (isChartNameTaken(this.getAdaptableApi(), candidate)) {
+            index += 1;
+            candidate = `Chart ${index}`;
+        }
+        return candidate;
     }
     // External lib charting service
     isExternalChartOpened(chartDefinition) {

package/src/Api/Internal/DashboardInternalApi.d.ts

@@ -1,6 +1,33 @@
 import { DashboardState } from '../../AdaptableState/DashboardState';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class DashboardInternalApi extends ApiBase {
+    /**
+     * Registry of reset-callbacks keyed by Custom-Toolbar name. Each
+     * `CustomToolbarCmp` registers itself on mount so the public
+     * {@link DashboardApi.resetCustomToolbarFormData} method can ask
+     * a specific instance to roll its `toolbarForm` data back to its
+     * declared `defaultValue`s without re-mounting the component.
+     */
+    private customToolbarFormResetters;
+    /**
+     * Register a reset callback for a Custom Toolbar. Idempotent: a second
+     * registration for the same name overwrites the previous entry, so a
+     * remount of the same toolbar always wins.
+     */
+    registerCustomToolbarFormResetter(toolbarName: string, resetter: () => void): void;
+    /**
+     * Tear down a previously-registered reset callback, but only if it's
+     * still the active one. Guards against a stale unmount clobbering a
+     * registration made by a fresh mount of the same toolbar.
+     */
+    unregisterCustomToolbarFormResetter(toolbarName: string, resetter: () => void): void;
+    /**
+     * Invokes the registered reset callback for the given toolbar (or all
+     * registered toolbars when `toolbarName` is omitted). Silently no-ops
+     * if no toolbar is registered under the given name - this is benign
+     * (e.g. the toolbar has not yet mounted, or it has no `toolbarForm`).
+     */
+    resetCustomToolbarFormData(toolbarName?: string): void;
     isToolbarInActiveTab(toolbarName: string, dashboardState: DashboardState): boolean;
     isToolbarCustom(toolbarName: string): boolean;
     getCustomToolbarRenderContainerId(customToolbarName: string): string;

package/src/Api/Internal/DashboardInternalApi.js

@@ -1,6 +1,47 @@
 import { ALL_TOOLBARS } from '../../AdaptableState/Common/Types';
 import { ApiBase } from '../Implementation/ApiBase';
 export class DashboardInternalApi extends ApiBase {
+    /**
+     * Registry of reset-callbacks keyed by Custom-Toolbar name. Each
+     * `CustomToolbarCmp` registers itself on mount so the public
+     * {@link DashboardApi.resetCustomToolbarFormData} method can ask
+     * a specific instance to roll its `toolbarForm` data back to its
+     * declared `defaultValue`s without re-mounting the component.
+     */
+    customToolbarFormResetters = new Map();
+    /**
+     * Register a reset callback for a Custom Toolbar. Idempotent: a second
+     * registration for the same name overwrites the previous entry, so a
+     * remount of the same toolbar always wins.
+     */
+    registerCustomToolbarFormResetter(toolbarName, resetter) {
+        this.customToolbarFormResetters.set(toolbarName, resetter);
+    }
+    /**
+     * Tear down a previously-registered reset callback, but only if it's
+     * still the active one. Guards against a stale unmount clobbering a
+     * registration made by a fresh mount of the same toolbar.
+     */
+    unregisterCustomToolbarFormResetter(toolbarName, resetter) {
+        if (this.customToolbarFormResetters.get(toolbarName) === resetter) {
+            this.customToolbarFormResetters.delete(toolbarName);
+        }
+    }
+    /**
+     * Invokes the registered reset callback for the given toolbar (or all
+     * registered toolbars when `toolbarName` is omitted). Silently no-ops
+     * if no toolbar is registered under the given name - this is benign
+     * (e.g. the toolbar has not yet mounted, or it has no `toolbarForm`).
+     */
+    resetCustomToolbarFormData(toolbarName) {
+        if (toolbarName) {
+            const fn = this.customToolbarFormResetters.get(toolbarName);
+            if (fn)
+                fn();
+            return;
+        }
+        this.customToolbarFormResetters.forEach((fn) => fn());
+    }
     isToolbarInActiveTab(toolbarName, dashboardState) {
         if (!dashboardState) {
             return false;

package/src/Api/Internal/EventInternalApi.d.ts

@@ -1,9 +1,8 @@
 import { IRowNode } from 'ag-grid-enterprise';
 import * as Redux from 'redux';
 import { CellDataChangedInfo } from '../../AdaptableState/Common/CellDataChangedInfo';
-import { AdaptableAlert, AdaptableFlashingCell, AdaptablePersistentState, AdaptableSharedEntity, AdaptableState, AdaptableTheme, CalculatedColumn, CreatedRowInfo, DashboardState, DataImportedInfo, DataSet, DeletedRowInfo, EditedRowInfo, LayoutState, RowDataChangedInfo, SystemStatusMessageInfo } from '../../types';
+import { AdaptableAlert, AdaptableFlashingCell, AdaptablePersistentState, AdaptableSharedEntity, AdaptableState, AdaptableTheme, CalculatedColumn, CreatedRowInfo, DashboardState, DataImportedInfo, DataSet, DeletedRowInfo, EditedRowInfo, LayoutState, RowDataChangedInfo, ReportSchedule, SystemStatusMessageInfo } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
-import { BaseSchedule } from '../../AdaptableState/Common/Schedule';
 import { LayoutChangedAction } from '../Events/LayoutChanged';
 export declare class EventInternalApi extends ApiBase {
     fireGridSortedEvent(): void;
@@ -13,7 +12,7 @@ export declare class EventInternalApi extends ApiBase {
     fireAlertFiredEvent(alertToFire: AdaptableAlert): void;
     fireThemeChangedEvent(theme: AdaptableTheme, trigger: 'ThemeSelected' | 'ThemeEdited'): void;
     fireLayoutChangedEvent(trigger: LayoutChangedAction, oldState: LayoutState, newState: LayoutState): void;
-    fireScheduleTriggeredEvent(schedule: BaseSchedule): void;
+    fireScheduledReportRanEvent(reportSchedule: ReportSchedule): void;
     fireDataSetSelectedEvent(dataSet: DataSet): void;
     fireSystemStatusMessageDisplayedEvent(systemStatusMessageInfo: SystemStatusMessageInfo): void;
     fireDataImportedEvent(importData: any[], addedRows: IRowNode[], updatedRows: IRowNode[]): DataImportedInfo;

package/src/Api/Internal/EventInternalApi.js

@@ -96,12 +96,12 @@ export class EventInternalApi extends ApiBase {
         };
         this.getEventApi().emit('LayoutChanged', layoutChangedInfo);
     }
-    fireScheduleTriggeredEvent(schedule) {
-        const scheduleTriggeredInfo = {
+    fireScheduledReportRanEvent(reportSchedule) {
+        const reportScheduleRanInfo = {
             ...this.getAdaptableInternalApi().buildBaseContext(),
-            schedule: schedule,
+            reportSchedule: reportSchedule,
         };
-        this.getEventApi().emit('ScheduleTriggered', scheduleTriggeredInfo);
+        this.getEventApi().emit('ReportScheduleRan', reportScheduleRanInfo);
     }
     fireDataSetSelectedEvent(dataSet) {
         if (this.isAdapTableReady()) {

package/src/Api/Internal/FormatColumnInternalApi.d.ts

@@ -17,6 +17,12 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * @param column
      * @param config
      * @returns list of FormatColumn
+     *
+     * Precedence rule: a Format Column never **wins** against an active Styled
+     * Column for any property the Styled Column claims (via its `Font` or
+     * `Cell` slot). The slice-level merging is applied downstream in
+     * `AgGridColumnAdapter.getFormatColumnAndStyledColumnCellStyle`; this API
+     * still returns every Format Column whose scope matches the column.
      */
     getFormatColumnsWithStyleForColumn(column: AdaptableColumn, config: FormatColumnConfig): FormatColumn[];
     /**

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -56,6 +56,12 @@ export class FormatColumnInternalApi extends ApiBase {
      * @param column
      * @param config
      * @returns list of FormatColumn
+     *
+     * Precedence rule: a Format Column never **wins** against an active Styled
+     * Column for any property the Styled Column claims (via its `Font` or
+     * `Cell` slot). The slice-level merging is applied downstream in
+     * `AgGridColumnAdapter.getFormatColumnAndStyledColumnCellStyle`; this API
+     * still returns every Format Column whose scope matches the column.
      */
     getFormatColumnsWithStyleForColumn(column, config) {
         const formatColumns = this.getAllFormatColumnWithStyle()

package/src/Api/Internal/GridInternalApi.js

@@ -3,6 +3,7 @@ import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import { getDateComparatorForGridCell, getGenericComparatorForGridCell, getNumericComparatorForGridCell, sortCellValueArrayNumeric, sortCellValueArrayDates, sortCellValueArray, } from '../../Utilities/Extensions/ArrayExtensions';
 import { multisort } from '@infinite-table/infinite-react';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
+import { getRuleAlertProperties } from '../../Utilities/Helpers/ScheduledAlertHelper';
 import UIHelper from '../../View/UIHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 export class GridInternalApi extends ApiBase {
@@ -194,7 +195,7 @@ export class GridInternalApi extends ApiBase {
     }
     getAlertRowStyle(params) {
         const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
-        const highlightRow = alert?.alertDefinition?.AlertProperties?.HighlightRow;
+        const highlightRow = getRuleAlertProperties(alert?.alertDefinition)?.HighlightRow;
         if (highlightRow) {
             return typeof highlightRow === 'object'
                 ? convertAdaptableStyleToCSS(highlightRow)
@@ -206,7 +207,7 @@ export class GridInternalApi extends ApiBase {
     }
     getAlertRowClass(params) {
         const alert = this.getAlertApi().internalApi.getAdaptableAlertWithHighlightRow(params.node);
-        const highlightRow = alert?.alertDefinition?.AlertProperties?.HighlightRow;
+        const highlightRow = getRuleAlertProperties(alert?.alertDefinition)?.HighlightRow;
         return typeof highlightRow === 'object' && highlightRow?.ClassName
             ? highlightRow?.ClassName
             : null;

package/src/Api/Internal/LayoutInternalApi.js

@@ -74,7 +74,10 @@ export class LayoutInternalApi extends ApiBase {
         }
         const layoutTagOptions = this.getLayoutOptions().layoutTagOptions;
         if (layoutTagOptions?.autoCheckTagsForLayouts == true) {
-            return ArrayExtensions.IsNullOrEmpty(object.Tags) ? true : object.Tags?.includes(layout.Name);
+            const tags = 'ReportSchedule' in object && object.ReportSchedule
+                ? object.ReportSchedule.Tags
+                : object.Tags;
+            return ArrayExtensions.IsNullOrEmpty(tags) ? true : tags?.includes(layout.Name);
         }
         const context = {
             adaptableObject: object,

package/src/Api/Internal/RowFormInternalApi.js

@@ -61,6 +61,16 @@ export class RowFormInternalApi extends ApiBase {
                 variant: 'raised',
                 tone: 'success',
             },
+            // The form component enriches every button's context with
+            // `formIsValid`. When no validation is configured this is always
+            // `true`, so the existing UX is unchanged - but consumers who supply
+            // `required` / `validate` / `min` / `max` / `pattern` via
+            // `rowFormField` automatically get a Save button that disables on
+            // invalid input.
+            disabled: (_button, context) => {
+                const formIsValid = context.formIsValid;
+                return formIsValid === false;
+            },
             onClick: (button, context) => {
                 // textOutput should not be saved, their values are set to display values
                 // we need to filter out the textOutput fields and add the primaryKey
@@ -148,13 +158,25 @@ export class RowFormInternalApi extends ApiBase {
                 ? this.getGridApi().getRawValueFromRowNode(rowNode, column.columnId)
                 : this.getGridApi().getDisplayValueFromRowNode(rowNode, column.columnId)
             : null;
-        return {
+        const baseField = {
             label: this.getRowFormFieldLabel(type, column, rowNode),
             name: column.columnId,
             defaultValue,
             fieldType,
             options: fieldValueOptions,
         };
+        // Allow consumers to override any subset of the auto-built field via
+        // `rowFormOptions.rowFormField`. We deliberately preserve `name` so a
+        // field always identifies itself by its column id - any attempt to
+        // rename would desync the form data from the underlying grid column.
+        const overrideFn = this.getRowFormOptions().rowFormField;
+        if (typeof overrideFn === 'function') {
+            const override = overrideFn(this.buildFormFieldLabelContext(type, column, rowNode));
+            if (override) {
+                return { ...baseField, ...override, name: baseField.name };
+            }
+        }
+        return baseField;
     }
     getRowFormFieldLabel(type, column, rowNode) {
         const customFieldLabel = typeof this.getRowFormOptions().rowFormFieldLabel === 'function'

package/src/Api/Internal/StateInternalApi.d.ts

@@ -0,0 +1,10 @@
+import { AdaptablePersistentState, AdaptableState } from '../../types';
+import { ApiBase } from '../Implementation/ApiBase';
+export declare class StateInternalApi extends ApiBase {
+    getAllStateForDevTools(): AdaptableState;
+    /**
+     * Replaces persisted Adaptable state with the supplied snapshot (e.g. from DevTools).
+     * Transient store sections (Internal, Popup, Comment, Plugins) are left unchanged.
+     */
+    restoreState(state: AdaptableState | AdaptablePersistentState): Promise<void>;
+}

package/src/Api/Internal/StateInternalApi.js

@@ -0,0 +1,84 @@
+import { getPersistableState, LoadState, InitState } from '../../Redux/Store/AdaptableStore';
+import { ApiBase } from '../Implementation/ApiBase';
+export class StateInternalApi extends ApiBase {
+    getAllStateForDevTools() {
+        let allState = this.getAdaptableApi().stateApi.getAllState();
+        if (allState.Layout && Array.isArray(allState.Layout.Layouts)) {
+            /**
+             * For devtools, we want to be able to restore states
+             * but some layouts may not have column sizing defined for
+             * some cols, and they will default to 200px
+             *
+             * but we need to send the state with the sizes computed,
+             * because on restore, in LayoutManager, if ColumnSizing[colId]
+             * has no value, it will leave the column width in the current state
+             * which is not what we want - if in the meantime the column was resized
+             *
+             * Therefore, we need to adjust the state and make sure
+             * all columns have a width set explicitly in the layout
+             *
+             * TODO make sure also pivot layouts are handled
+             */
+            allState = { ...allState };
+            allState.Layout = { ...allState.Layout };
+            allState.Layout.Layouts = allState.Layout.Layouts.map((layout) => {
+                let ColumnSizing = layout.ColumnSizing;
+                if (Array.isArray(layout.TableColumns)) {
+                    layout.TableColumns.forEach((colId) => {
+                        if (!ColumnSizing[colId]) {
+                            ColumnSizing[colId] = {
+                                Width: this._adaptable.getDefaultColumnWidthForCol(colId),
+                            };
+                        }
+                    });
+                }
+                return {
+                    ...layout,
+                    ColumnSizing,
+                };
+            });
+        }
+        return allState;
+    }
+    /**
+     * Replaces persisted Adaptable state with the supplied snapshot (e.g. from DevTools).
+     * Transient store sections (Internal, Popup, Comment, Plugins) are left unchanged.
+     */
+    restoreState(state) {
+        return new Promise((resolve, reject) => {
+            this.getAdaptableInternalApi().executeWithProgressIndicator('Restoring state from DevTools...', () => {
+                try {
+                    const agGridOptions = {
+                        columnDefs: this._adaptable.agGridAdapter.getGridOption('columnDefs'),
+                        autoGroupColumnDef: this._adaptable.agGridAdapter.getGridOption('autoGroupColumnDef'),
+                        rowModelType: this._adaptable.agGridAdapter.getGridOption('rowModelType'),
+                        treeData: this._adaptable.agGridAdapter.getGridOption('treeData'),
+                    };
+                    const clonedState = state.Internal
+                        ? JSON.parse(JSON.stringify(state))
+                        : getPersistableState(JSON.parse(JSON.stringify(state)));
+                    let processedState = this._adaptable.normalizeAdaptableState(clonedState, agGridOptions);
+                    // processedState = getPersistableState(
+                    //   this.getOptions().stateOptions.applyState(
+                    //     processedState,
+                    //     buildAdaptableStateFunctionConfig(this._adaptable)
+                    //   )
+                    // );
+                    this.getAdaptableStore().TheStore.dispatch(LoadState(processedState));
+                    this.getAdaptableStore().TheStore.dispatch(InitState());
+                    this._adaptable.refreshLayout();
+                    void this.getAdaptableStore()
+                        .saveStateNow(this._adaptable)
+                        .then(() => resolve())
+                        .catch(reject);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    this.getUserInterfaceApi().hideProgressIndicator();
+                }
+            });
+        });
+    }
+}

package/src/Api/Internal/StyledColumnInternalApi.d.ts

@@ -6,6 +6,8 @@ import { PredicateDefHandlerContext } from '../../types';
 export declare class StyledColumnInternalApi extends ApiBase {
     getMinValueForNumericColumn(column: AdaptableColumn): number | undefined;
     getMaxValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    getAvgValueForNumericColumn(column: AdaptableColumn): number | undefined;
+    getMedianValueForNumericColumn(column: AdaptableColumn): number | undefined;
     /**
      * Gets the Minimum Value to display for a Styled Column
      * @param styledColumn Styled Column to check