@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.1

package/src/Api/Implementation/AlertApiImpl.js

@@ -10,149 +10,43 @@ const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
 const AdaptableAlert_1 = require("../../PredefinedConfig/Common/AdaptableAlert");
-const AdaptableQuery_1 = require("../../PredefinedConfig/Common/AdaptableQuery");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const AlertInternalApi_1 = require("../Internal/AlertInternalApi");
+const logDeprecation_1 = require("../../Utilities/logDeprecation");
 class AlertApiImpl extends ApiBase_1.ApiBase {
+    constructor(adaptable) {
+        super(adaptable);
+        this.internalApi = new AlertInternalApi_1.AlertInternalApi(adaptable);
+    }
     getAlertState() {
         return this.getAdaptableState().Alert;
     }
-    getAdaptableFormByName(name) {
-        var _a;
-        const alertForms = this.getAlertOptions().alertForms || [];
-        return (_a = alertForms.find((f) => f.name === name)) === null || _a === void 0 ? void 0 : _a.form;
-    }
     getAlertDefinitions(config) {
         var _a;
         return ((_a = this.handleLayoutAssociatedObjects(this.getAlertState().AlertDefinitions, 'Alert', config)) !== null && _a !== void 0 ? _a : []);
     }
-    getAlertDefinitionById(id) {
-        return this.getAlertDefinitions().find((alert) => (alert === null || alert === void 0 ? void 0 : alert.Uuid) === id);
+    getSuspendedAlertDefinitions(config) {
+        return this.getAlertDefinitions(config).filter((alertDefinition) => alertDefinition.IsSuspended);
     }
-    getNonReactiveAlertDefinitions() {
-        return this.getAlertDefinitions().filter((alertDef) => !(0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
+    getActiveAlertDefinitions(config) {
+        return this.getAlertDefinitions(config).filter((alertDefinition) => !alertDefinition.IsSuspended);
     }
-    getActiveNonReactiveAlertDefinitions() {
-        return this.getNonReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
-    }
-    getReactiveAlertDefinitions() {
-        return this.getAlertDefinitions().filter((alertDef) => (0, AdaptableQuery_1.isReactiveQuery)(alertDef.Rule));
-    }
-    getActiveReactiveAlertDefinitions() {
-        return this.getReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
+    deleteAlertDefinition(alertDefinition) {
+        this.dispatchAction(AlertRedux.AlertDefinitionDelete(alertDefinition));
     }
-    getAlertDefinitionsWithPreventEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties != null && a.AlertProperties.PreventEdit === true);
-    }
-    getAlertDefinitionsWithAllowEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties == null || a.AlertProperties.PreventEdit !== true);
+    getAlertDefinitionById(id) {
+        return this.getAlertDefinitions().find((alert) => (alert === null || alert === void 0 ? void 0 : alert.Uuid) === id);
     }
     addAlertDefinition(alertDefinition) {
         this.addUidToAdaptableObject(alertDefinition);
         this.dispatchAction(AlertRedux.AlertDefinitionAdd(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    executeAlertButton(button, context) {
-        if (button.Action) {
-            let actions = button.Action;
-            if (!Array.isArray(actions)) {
-                actions = [actions];
-            }
-            actions.forEach((action) => {
-                var _a;
-                const buttonOnClick = (_a = this.getAlertOptions().actionHandlers) === null || _a === void 0 ? void 0 : _a.find((x) => x.name === action);
-                buttonOnClick === null || buttonOnClick === void 0 ? void 0 : buttonOnClick.handler(button, context);
-                this.adaptable.api.alertApi.executeAlertAction(action, {
-                    alertDefinition: context.alert.alertDefinition,
-                    cellDataChangedInfo: (0, AdaptableAlert_1.isAdaptableCellChangedAlert)(context.alert)
-                        ? context.alert.cellDataChangedInfo
-                        : null,
-                    gridDataChangedInfo: (0, AdaptableAlert_1.isAdaptableRowChangedAlert)(context.alert)
-                        ? context.alert.gridDataChangedInfo
-                        : null,
-                    formData: context.formData,
-                });
-            });
-        }
-    }
-    executeAlertAction(actionName, details) {
-        const { alertDefinition, cellDataChangedInfo: cellDataChangedInfo, gridDataChangedInfo, } = details;
-        const getBackgroundColor = (alertDefinition) => {
-            var _a;
-            const highlightType = (_a = alertDefinition.MessageType) !== null && _a !== void 0 ? _a : 'Info';
-            let backgroundColor = '';
-            switch (highlightType) {
-                case 'Error':
-                    backgroundColor = 'var(--ab-color-error)';
-                    break;
-                case 'Info':
-                    backgroundColor = 'var(--ab-color-info)';
-                    break;
-                case 'Success':
-                    backgroundColor = 'var(--ab-color-success)';
-                    break;
-                case 'Warning':
-                    backgroundColor = 'var(--ab-color-warn)';
-            }
-            return backgroundColor;
-        };
-        if (actionName === 'highlight-cell' && cellDataChangedInfo) {
-            const backgroundColor = getBackgroundColor(alertDefinition);
-            this.adaptable.api.gridApi.highlightCell({
-                columnId: cellDataChangedInfo.column.columnId,
-                primaryKeyValue: cellDataChangedInfo.primaryKeyValue,
-                highlightStyle: {
-                    BackColor: backgroundColor,
-                },
-                timeout: this.getAlertOptions().cellHighlightDuration,
-            });
-        }
-        if (actionName === 'highlight-row' && cellDataChangedInfo) {
-            const rowsHighlightInfo = {
-                primaryKeyValues: [cellDataChangedInfo.primaryKeyValue],
-                highlightStyle: {
-                    BackColor: getBackgroundColor(alertDefinition),
-                },
-                timeout: this.getAlertOptions().rowHighlightDuration,
-            };
-            this.adaptable.api.gridApi.highlightRows(rowsHighlightInfo);
-        }
-        if (actionName === 'highlight-row' &&
-            gridDataChangedInfo &&
-            // no sense to highlight a deleted(non-existing) row
-            (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete') {
-            const primaryKeyValues = this.adaptable.api.gridApi.getPrimaryKeyValuesForRowNodes(gridDataChangedInfo.rowNodes);
-            const rowsHighlightInfo = {
-                primaryKeyValues,
-                highlightStyle: {
-                    BackColor: getBackgroundColor(alertDefinition),
-                },
-                timeout: this.getAlertOptions().rowHighlightDuration,
-            };
-            this.adaptable.api.gridApi.highlightRows(rowsHighlightInfo);
-        }
-        if (actionName === 'jump-to-cell' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.jumpToCell(cellDataChangedInfo.primaryKeyValue, cellDataChangedInfo.column.columnId);
-        }
-        if (actionName === 'jump-to-row' &&
-            gridDataChangedInfo &&
-            // no sense to jump to a deleted(non-existing) row
-            (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete') {
-            const [firstRowNode] = gridDataChangedInfo.rowNodes;
-            const targetRowNodePrimaryKeyValue = this.adaptable.api.gridApi.getPrimaryKeyValueForRowNode(firstRowNode);
-            if (targetRowNodePrimaryKeyValue) {
-                this.adaptable.api.gridApi.jumpToRow(targetRowNodePrimaryKeyValue);
-            }
-        }
-        if (actionName === 'jump-to-column' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.jumpToColumn(cellDataChangedInfo.column.columnId);
-        }
-        if (actionName === 'suspend') {
-            this.adaptable.api.alertApi.suspendAlertDefinition(alertDefinition);
-        }
-        if (actionName === 'undo' && cellDataChangedInfo) {
-            this.adaptable.api.gridApi.undoCellEdit(cellDataChangedInfo);
-        }
-    }
     async displayAlert(alertToShow) {
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'displayAlert', 'showAdaptableAlert');
+        await this.showAdaptableAlert(alertToShow);
+    }
+    async showAdaptableAlert(alertToShow) {
         var _a, _b;
         // 3 things we always do with an alert are:
         // 1. Dispatch the Alert (so it appears in the toolbar)
@@ -244,41 +138,36 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
             }
         }
     }
-    publishAlertFiredEvent(alertToFire) {
-        const alertFiredInfo = {
-            adaptableApi: this.adaptable.api,
-            alert: alertToFire,
-        };
-        this.adaptable.api.eventApi.emit('AlertFired', alertFiredInfo);
-    }
     displayMessageAlertPopup(alertToDisplayAsPopup) {
-        this.dispatchAction(PopupRedux.PopupShowAlert(alertToDisplayAsPopup));
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'displayMessageAlertPopup', 'showAdaptableAlertAsToast');
+        this.showAdaptableAlertAsToast(alertToDisplayAsPopup);
+    }
+    showAdaptableAlertAsToast(alert) {
+        this.dispatchAction(PopupRedux.PopupShowAlert(alert));
     }
-    showAlert(alertHeader, alertMessage, messageType, alertProperties) {
+    async showAlert(alertHeader, alertMessage, messageType, alertProperties) {
         const alertDefinition = ObjectFactory_1.default.CreateInternalAlertDefinitionForMessages(messageType, alertProperties);
         let alertToShow = ObjectFactory_1.default.CreateGenericAlert(alertHeader, alertMessage, alertDefinition);
-        this.displayAlert(alertToShow);
+        await this.showAdaptableAlert(alertToShow);
     }
-    showAlertInfo(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Info', alertProperties);
+    async showAlertInfo(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Info', alertProperties);
     }
-    showAlertSuccess(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Success', alertProperties);
+    async showAlertSuccess(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Success', alertProperties);
     }
-    showAlertWarning(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Warning', alertProperties);
+    async showAlertWarning(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Warning', alertProperties);
     }
-    showAlertError(alertHeader, alertMessage, alertProperties) {
-        this.showAlert(alertHeader, alertMessage, 'Error', alertProperties);
+    async showAlertError(alertHeader, alertMessage, alertProperties) {
+        await this.showAlert(alertHeader, alertMessage, 'Error', alertProperties);
     }
-    showAlertPopup() {
+    openAlertSettingsPanel() {
         this.showModulePopup(ModuleConstants.AlertModuleId);
     }
-    getAlertPredicateDefs() {
-        return this.adaptable.api.predicateApi.getPredicateDefsByModuleScope('alert');
-    }
-    getAlertPredicateDefsForScope(scope) {
-        return this.getAlertPredicateDefs().filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    showAlertPopup() {
+        (0, logDeprecation_1.logDeprecation)('AlertApi', 'showAlertPopup', 'openAlertSettingsPanel');
+        this.openAlertSettingsPanel();
     }
     editAlertDefinition(alertDefinition) {
         this.dispatchAction(AlertRedux.AlertDefinitionEdit(alertDefinition));
@@ -292,31 +181,158 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         this.dispatchAction(AlertRedux.AlertDefinitionUnSuspend(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    getAlertDescription(alertDefinition, cellDataChangedInfo) {
-        var _a;
-        const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageText;
-        if (alertMessageFunction) {
-            const alertMessageContext = {
-                alertDefinition: alertDefinition,
-                cellDataChangedInfo: cellDataChangedInfo,
-            };
-            const returnText = alertMessageFunction(alertMessageContext);
-            if (returnText) {
-                return returnText;
+    evaluateAlerts(alertDefinitions) {
+        const filterScopeAllDefinitions = (alertDefinition) => {
+            if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+                !this.getAdaptableApi().queryLanguageApi.getAdaptableQueryExpression(alertDefinition.Rule)) {
+                // we don't support scope ALL without an expression
+                // the predicates for scope ALL do NOT make any sense for a programmatic evaluation
+                return false;
             }
+            return true;
+        };
+        const relevantAlertDefinitions = alertDefinitions.filter((alertDefinition) => filterScopeAllDefinitions(alertDefinition));
+        const relevantColumnIds = new Set();
+        relevantAlertDefinitions.forEach((alertDefinition) => {
+            this.getRelevantColumnIdsForAlertDefinition(alertDefinition).forEach((relevantColumnId) => relevantColumnIds.add(relevantColumnId));
+        });
+        if (!relevantColumnIds.size) {
+            return;
         }
-        if (alertDefinition.MessageText != null) {
-            return alertDefinition.MessageText;
+        const cellDataChangedInfos = this.createCellDataChangeInfoStubs(Array.from(relevantColumnIds));
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+            const alertDefinitions = this.getAdaptableApi()
+                .alertApi.internalApi.getAlertDefinitionsForCellDataChange(cellDataChangedInfo)
+                .filter((alertDefinition) => filterScopeAllDefinitions(alertDefinition))
+                // some alert definitions might NOT be relevant for the given locator
+                .filter((alertDefinition) => relevantAlertDefinitions.some((relevantAlertDefinition) => relevantAlertDefinition.Uuid === alertDefinition.Uuid));
+            this.getAdaptableApi().alertApi.internalApi.showAlertForDefinitions(cellDataChangedInfo, alertDefinitions);
+        });
+    }
+    findAlertDefinitions(criteria) {
+        return this.getAdaptableApi().internalApi.findAdaptableObjectsByLookupCriteria(criteria, this.getAlertDefinitions({
+            includeLayoutNotAssociatedObjects: true,
+        }));
+    }
+    getRelevantColumnIdsForAlertDefinition(alertDefinition) {
+        //  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.getAdaptableApi().queryLanguageApi.getAdaptableQueryExpression(alertDefinition.Rule);
+        if (this.getAdaptableApi().scopeApi.scopeIsAll(alertDefinition.Scope) &&
+            StringExtensions_1.default.IsNotNullOrEmpty(ruleExpression)) {
+            // return only first referenced column (otherwise we would generate multiple alerts for the same row)
+            const queryColumns = this.getAdaptableApi()
+                .internalApi.getQueryLanguageService()
+                .getColumnsFromExpression(ruleExpression);
+            return queryColumns.length > 0 ? [queryColumns[0]] : [];
         }
-        let scopeDescription = this.adaptable.api.scopeApi.getScopeDescription(alertDefinition.Scope);
-        let ruleDescription = this.getAlertRuleDescription(alertDefinition);
-        return scopeDescription + ' - ' + ruleDescription;
-    }
-    getAlertRuleDescription(alert) {
-        let ruleDescription = alert.Rule.Predicate
-            ? this.adaptable.api.predicateApi.predicateToString(alert.Rule.Predicate)
-            : this.adaptable.api.internalApi.getAdaptableQueryExpressionText(alert.Rule);
-        return ruleDescription;
+        else {
+            // otherwise return all columns for given scope
+            return this.getAdaptableApi()
+                .scopeApi.getColumnsForScope(alertDefinition.Scope)
+                .map((adaptableColumn) => adaptableColumn.columnId);
+        }
+    }
+    createCellDataChangeInfoStubs(relevantColumnIds) {
+        const cellDataChangeInfos = [];
+        const relevantColumns = this.getAdaptableApi()
+            .columnApi.getColumnsWithColumnIds(relevantColumnIds)
+            .filter(Boolean);
+        const changedAt = Date.now();
+        this.adaptable.forAllRowNodesDo((rowNode) => {
+            relevantColumns.forEach((column) => {
+                const cellDataChangeInfoStub = {
+                    changedAt,
+                    rowNode,
+                    column,
+                    rowData: rowNode.data,
+                    oldValue: null,
+                    newValue: this.adaptable.getRawValueFromRowNode(rowNode, column.columnId),
+                    primaryKeyValue: this.adaptable.getPrimaryKeyValueFromRowNode(rowNode),
+                };
+                cellDataChangeInfos.push(cellDataChangeInfoStub);
+            });
+        });
+        return cellDataChangeInfos;
+    }
+    /**
+     *  DEPRECATED INTERNAL METHODS
+     */
+    executeAlertAction(actionName, details) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertAction');
+        this.internalApi.executeAlertAction(actionName, details);
+    }
+    executeAlertButton(button, context) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertButton');
+        this.internalApi.executeAlertButton(button, context);
+    }
+    getActiveNonReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'executeAlertButton');
+        return this.internalApi.getActiveNonReactiveAlertDefinitions();
+    }
+    getActiveReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getActiveReactiveAlertDefinitions');
+        return this.internalApi.getActiveReactiveAlertDefinitions();
+    }
+    getAlertDefinitionsWithAllowEdit() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDefinitionsWithAllowEdit');
+        return this.internalApi.getAlertDefinitionsWithAllowEdit();
+    }
+    getAlertDefinitionsWithPreventEdit() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDefinitionsWithPreventEdit');
+        return this.internalApi.getAlertDefinitionsWithPreventEdit();
+    }
+    getAlertDescription(alertDefinition, cellDataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertDescription');
+        return this.internalApi.getAlertDescription(alertDefinition, cellDataChangedInfo);
+    }
+    getAlertMessageTitle(alertDefinition, cellDataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertMessageTitle');
+        return this.internalApi.getAlertMessageTitle(alertDefinition, cellDataChangedInfo);
+    }
+    getAlertPredicateDefsForScope(scope) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertPredicateDefsForScope');
+        return this.internalApi.getAlertPredicateDefsForScope(scope);
+    }
+    getAlertRuleDescription(alertDefinition) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertRuleDescription');
+        return this.internalApi.getAlertRuleDescription(alertDefinition);
+    }
+    getAlertTypeForAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getAlertTypeForAdaptableAlert');
+        return this.internalApi.getAlertTypeForAdaptableAlert(alert);
+    }
+    getCustomAlertDescription(alertDefinition, dataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getCustomAlertDescription');
+        return this.internalApi.getCustomAlertDescription(alertDefinition, dataChangedInfo);
+    }
+    getCustomAlertMessageTitle(alertDefinition, dataChangedInfo) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getCustomAlertMessageTitle');
+        return this.internalApi.getCustomAlertMessageTitle(alertDefinition, dataChangedInfo);
+    }
+    getNonReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getNonReactiveAlertDefinitions');
+        return this.internalApi.getNonReactiveAlertDefinitions();
+    }
+    getReactiveAlertDefinitions() {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'getReactiveAlertDefinitions');
+        return this.internalApi.getReactiveAlertDefinitions();
+    }
+    isCellChangedAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isCellChangedAdaptableAlert');
+        return this.internalApi.isCellChangedAdaptableAlert(alert);
+    }
+    isGenericAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isGenericAdaptableAlert');
+        return this.internalApi.isGenericAdaptableAlert(alert);
+    }
+    isRowChangedAdaptableAlert(alert) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'isRowChangedAdaptableAlert');
+        return this.internalApi.isRowChangedAdaptableAlert(alert);
+    }
+    publishAlertFiredEvent(alertToFire) {
+        (0, logDeprecation_1.logDeprecationInternal)('AlertApi', 'publishAlertFiredEvent');
+        return this.internalApi.publishAlertFiredEvent(alertToFire);
     }
 }
 exports.AlertApiImpl = AlertApiImpl;

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

@@ -7,11 +7,12 @@ import { ModuleInfo } from '../../Strategy/Interface/IModule';
 import { AdaptableOptions } from '../../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../AdaptableApi';
 import { ExportOptions } from '../../AdaptableOptions/ExportOptions';
-import { ActionOptions, ContainerOptions, DashboardOptions, EditOptions, FilterOptions, GeneralOptions, LayoutAssociatedObject, LayoutOptions, MenuOptions, SearchOptions, StateOptions, TeamSharingOptions, UserInterfaceOptions } from '../../types';
+import { ActionApi, ActionOptions, AlertApi, ApplicationApi, BulkUpdateApi, CalculatedColumnApi, CalendarApi, CellSummaryApi, ChartingApi, ColumnApi, ConfigApi, ContainerOptions, CustomSortApi, DashboardApi, DashboardOptions, DataChangeHistoryApi, DataSetApi, EditOptions, EntitlementApi, EventApi, ExportApi, FilterApi, FilterOptions, FlashingCellApi, FormatColumnApi, FreeTextColumnApi, GeneralOptions, GridApi, LayoutApi, LayoutAssociatedObject, LayoutOptions, MenuOptions, PluginsApi, PlusMinusApi, PredicateApi, QueryApi, QueryLanguageApi, QuickSearchApi, ScheduleApi, ScopeApi, SearchOptions, SettingsPanelApi, ShortcutApi, SmartEditApi, StateOptions, StatusBarApi, StyledColumnApi, SystemStatusApi, TeamSharingApi, TeamSharingOptions, ThemeApi, ToolPanelApi, UserInterfaceApi, UserInterfaceOptions } from '../../types';
 import { NotificationsOptions } from '../../AdaptableOptions/NotificationsOptions';
 import { ToolPanelOptions } from '../../AdaptableOptions/ToolPanelOptions';
 import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
-import { AdaptableQLOptions, ExpressionOptions } from '../../AdaptableOptions/AdaptableQLOptions';
+import { AdaptableQLOptions } from '../../AdaptableOptions/AdaptableQLOptions';
+import { ExpressionOptions } from '../../AdaptableOptions/ExpressionOptions';
 import { AlertOptions } from '../../AdaptableOptions/AlertOptions';
 import { ColumnOptions } from '../../AdaptableOptions/ColumnOptions';
 export declare abstract class ApiBase {
@@ -31,7 +32,7 @@ export declare abstract class ApiBase {
      */
     protected checkItemExists(item: any, name: string, type: string): boolean;
     protected checkArrayExists(array: any): boolean;
-    protected handleLayoutAssociatedObjects<T extends LayoutAssociatedObject>(associatedObjects: T[], module: AdaptableModule, config?: {
+    protected handleLayoutAssociatedObjects<T extends LayoutAssociatedObject>(objectList: T[], module: AdaptableModule, config?: {
         includeLayoutNotAssociatedObjects?: boolean;
         associatedWithLayout?: string;
     }): T[];
@@ -70,6 +71,47 @@ export declare abstract class ApiBase {
     protected getToolPanelOptions(): ToolPanelOptions;
     protected getExpressionOptions(): ExpressionOptions;
     protected getAdaptableApi(): AdaptableApi;
+    protected getActionApi(): ActionApi;
+    protected getApplicationApi(): ApplicationApi;
+    protected getAlertApi(): AlertApi;
+    protected getFlashingCellApi(): FlashingCellApi;
+    protected getPredicateApi(): PredicateApi;
+    protected getBulkUpdateApi(): BulkUpdateApi;
+    protected getCalendarApi(): CalendarApi;
+    protected getCalculatedColumnApi(): CalculatedColumnApi;
+    protected getCellSummaryApi(): CellSummaryApi;
+    protected getColumnApi(): ColumnApi;
+    protected getConfigApi(): ConfigApi;
+    protected getCustomSortApi(): CustomSortApi;
+    protected getDashboardApi(): DashboardApi;
+    protected getDataSetApi(): DataSetApi;
+    protected getEntitlementApi(): EntitlementApi;
+    protected getEventApi(): EventApi;
+    protected getExportApi(): ExportApi;
+    protected getFormatColumnApi(): FormatColumnApi;
+    protected getFreeTextColumnApi(): FreeTextColumnApi;
+    protected getGridApi(): GridApi;
+    protected getLayoutApi(): LayoutApi;
+    protected getPlusMinusApi(): PlusMinusApi;
+    protected getQuickSearchApi(): QuickSearchApi;
+    protected getScheduleApi(): ScheduleApi;
+    protected getShortcutApi(): ShortcutApi;
+    protected getSmartEditApi(): SmartEditApi;
+    protected getFilterApi(): FilterApi;
+    protected getSystemStatusApi(): SystemStatusApi;
+    protected getThemeApi(): ThemeApi;
+    protected getUserInterfaceApi(): UserInterfaceApi;
+    protected getQueryApi(): QueryApi;
+    protected getQueryLanguageApi(): QueryLanguageApi;
+    protected getPluginsApi(): PluginsApi;
+    protected getSettingsPanelApi(): SettingsPanelApi;
+    protected getStyledColumnApi(): StyledColumnApi;
+    protected getToolPanelApi(): ToolPanelApi;
+    protected getTeamSharingApi(): TeamSharingApi;
+    protected getScopeApi(): ScopeApi;
+    protected getDataChangeHistoryApi(): DataChangeHistoryApi;
+    protected getChartingApi(): ChartingApi;
+    protected getStatusBarApi(): StatusBarApi;
     destroy(): void;
 }
 /**

package/src/Api/Implementation/ApiBase.js

@@ -13,7 +13,6 @@ class ApiBase {
      */
     constructor(adaptable) {
         this.adaptable = adaptable;
-        this.adaptable = adaptable;
     }
     /**
      * Base api helper method which ensure that Adaptable Object being used in the function is not null or undefined
@@ -37,12 +36,14 @@ class ApiBase {
         }
         return true;
     }
-    handleLayoutAssociatedObjects(associatedObjects = [], module, config) {
+    handleLayoutAssociatedObjects(objectList = [], module, config) {
+        if (config === null || config === void 0 ? void 0 : config.includeLayoutNotAssociatedObjects) {
+            return objectList;
+        }
         const associatedLayout = (config === null || config === void 0 ? void 0 : config.associatedWithLayout)
             ? this.adaptable.api.layoutApi.getLayoutByName(config.associatedWithLayout)
             : this.getAdaptableApi().layoutApi.getCurrentLayout();
-        return associatedObjects.filter((associatedObject) => (config === null || config === void 0 ? void 0 : config.includeLayoutNotAssociatedObjects) ||
-            this.adaptable.api.internalApi.isObjectAvailableInLayout(associatedObject, module, associatedLayout));
+        return objectList.filter((objectItem) => this.adaptable.api.layoutApi.internalApi.isObjectAvailableInLayout(objectItem, module, associatedLayout));
     }
     /**
      * Base api Helper method that dispatches a *Redux Action* to the Store
@@ -63,7 +64,7 @@ class ApiBase {
         return this.adaptable.adaptableStore.TheStore.getState();
     }
     // Add the Uuid to the object if not present;
-    // Its generally done in Redux also but no harm checking in Api also in case we missed it.
+    // It's generally done in Redux also but no harm checking in Api also in case we missed it.
     addUidToAdaptableObject(adaptableObject) {
         if (!adaptableObject.Uuid) {
             adaptableObject.Uuid = (0, Uuid_1.createUuid)();
@@ -141,6 +142,129 @@ class ApiBase {
     getAdaptableApi() {
         return this.adaptable.api;
     }
+    getActionApi() {
+        return this.getAdaptableApi().actionApi;
+    }
+    getApplicationApi() {
+        return this.getAdaptableApi().applicationApi;
+    }
+    getAlertApi() {
+        return this.getAdaptableApi().alertApi;
+    }
+    getFlashingCellApi() {
+        return this.getAdaptableApi().flashingCellApi;
+    }
+    getPredicateApi() {
+        return this.getAdaptableApi().predicateApi;
+    }
+    getBulkUpdateApi() {
+        return this.getAdaptableApi().bulkUpdateApi;
+    }
+    getCalendarApi() {
+        return this.getAdaptableApi().calendarApi;
+    }
+    getCalculatedColumnApi() {
+        return this.getAdaptableApi().calculatedColumnApi;
+    }
+    getCellSummaryApi() {
+        return this.getAdaptableApi().cellSummaryApi;
+    }
+    getColumnApi() {
+        return this.getAdaptableApi().columnApi;
+    }
+    getConfigApi() {
+        return this.getAdaptableApi().configApi;
+    }
+    getCustomSortApi() {
+        return this.getAdaptableApi().customSortApi;
+    }
+    getDashboardApi() {
+        return this.getAdaptableApi().dashboardApi;
+    }
+    getDataSetApi() {
+        return this.getAdaptableApi().dataSetApi;
+    }
+    getEntitlementApi() {
+        return this.getAdaptableApi().entitlementApi;
+    }
+    getEventApi() {
+        return this.getAdaptableApi().eventApi;
+    }
+    getExportApi() {
+        return this.getAdaptableApi().exportApi;
+    }
+    getFormatColumnApi() {
+        return this.getAdaptableApi().formatColumnApi;
+    }
+    getFreeTextColumnApi() {
+        return this.getAdaptableApi().freeTextColumnApi;
+    }
+    getGridApi() {
+        return this.getAdaptableApi().gridApi;
+    }
+    getLayoutApi() {
+        return this.getAdaptableApi().layoutApi;
+    }
+    getPlusMinusApi() {
+        return this.getAdaptableApi().plusMinusApi;
+    }
+    getQuickSearchApi() {
+        return this.getAdaptableApi().quickSearchApi;
+    }
+    getScheduleApi() {
+        return this.getAdaptableApi().scheduleApi;
+    }
+    getShortcutApi() {
+        return this.getAdaptableApi().shortcutApi;
+    }
+    getSmartEditApi() {
+        return this.getAdaptableApi().smartEditApi;
+    }
+    getFilterApi() {
+        return this.getAdaptableApi().filterApi;
+    }
+    getSystemStatusApi() {
+        return this.getAdaptableApi().systemStatusApi;
+    }
+    getThemeApi() {
+        return this.getAdaptableApi().themeApi;
+    }
+    getUserInterfaceApi() {
+        return this.getAdaptableApi().userInterfaceApi;
+    }
+    getQueryApi() {
+        return this.getAdaptableApi().queryApi;
+    }
+    getQueryLanguageApi() {
+        return this.getAdaptableApi().queryLanguageApi;
+    }
+    getPluginsApi() {
+        return this.getAdaptableApi().pluginsApi;
+    }
+    getSettingsPanelApi() {
+        return this.getAdaptableApi().settingsPanelApi;
+    }
+    getStyledColumnApi() {
+        return this.getAdaptableApi().styledColumnApi;
+    }
+    getToolPanelApi() {
+        return this.getAdaptableApi().toolPanelApi;
+    }
+    getTeamSharingApi() {
+        return this.getAdaptableApi().teamSharingApi;
+    }
+    getScopeApi() {
+        return this.getAdaptableApi().scopeApi;
+    }
+    getDataChangeHistoryApi() {
+        return this.getAdaptableApi().dataChangeHistoryApi;
+    }
+    getChartingApi() {
+        return this.getAdaptableApi().chartingApi;
+    }
+    getStatusBarApi() {
+        return this.getAdaptableApi().statusBarApi;
+    }
     destroy() {
         delete this.adaptable;
     }

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

@@ -1,6 +1,6 @@
 import { ApiBase } from './ApiBase';
 import { ApplicationApi } from '../ApplicationApi';
-import { ApplicationState, ApplicationDataEntry } from '../../types';
+import { ApplicationDataEntry, ApplicationState } from '../../types';
 export declare class ApplicationApiImpl extends ApiBase implements ApplicationApi {
     getApplicationState(): ApplicationState;
     getApplicationDataEntries(): ApplicationDataEntry[];

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

@@ -3,6 +3,7 @@ import { BulkUpdateApi } from '../BulkUpdateApi';
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
 export declare class BulkUpdateApiImpl extends ApiBase implements BulkUpdateApi {
     getBulkUpdateValue(): string;
+    openBulkUpdateSettingsPanel(): void;
     showBulkUpdatePopup(): void;
     applyBulkUpdate(gridCells: GridCell[]): void;
     setBulkUpdateValue(bulkUpdateValue: string): void;