@adaptabletools/adaptable 10.0.0-canary.0

package/src/Api/Implementation/SystemStatusApiImpl.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemStatusApiImpl = void 0;
+const tslib_1 = require("tslib");
+const SystemStatusRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemStatusRedux"));
+const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
+const ApiBase_1 = require("./ApiBase");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+const react_dom_1 = require("react-dom");
+const react_1 = require("react");
+const UIHelper_1 = tslib_1.__importDefault(require("../../View/UIHelper"));
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
+class SystemStatusApiImpl extends ApiBase_1.ApiBase {
+    setSystemStatus(statusMessage, messageType, statusFurtherInformation) {
+        let systemStatusMessageInfo = ObjectFactory_1.default.CreateSystemStatusMessageInfo(statusMessage, messageType, statusFurtherInformation ? statusFurtherInformation : '');
+        this.adaptable.api.internalApi.addSystemStatusMessageInfo(systemStatusMessageInfo);
+        // publish the event
+        this.fireSystemStatusMessageDisplayedEvent(systemStatusMessageInfo);
+        if (this.getSystemStatusOptions().showMessageAsAlert) {
+            let fullMessage = statusMessage;
+            if (StringExtensions_1.default.IsNotNullOrEmpty(statusFurtherInformation)) {
+                fullMessage += '\n' + statusFurtherInformation;
+            }
+            switch (messageType) {
+                case 'Success':
+                    this.adaptable.api.alertApi.showAlertSuccess('System Status Success', fullMessage);
+                    return;
+                case 'Info':
+                    this.adaptable.api.alertApi.showAlertInfo('System Status Info', fullMessage);
+                    return;
+                case 'Warning':
+                    this.adaptable.api.alertApi.showAlertWarning('System Status Warning', fullMessage);
+                    return;
+                case 'Error':
+                    this.adaptable.api.alertApi.showAlertError('System Status Error', fullMessage);
+                    return;
+            }
+        }
+        if (this.getContainerOptions().systemStatusContainer != null) {
+            this.displayMessageInDiv(statusMessage, statusFurtherInformation, messageType);
+        }
+        // doesnt do anything but useful for Audit
+        this.dispatchAction(SystemStatusRedux.SystemStatusSetMesage(systemStatusMessageInfo));
+    }
+    displayMessageInDiv(statusMessage, statusFurtherInformation, messageType) {
+        if (!this.systemStatusDiv) {
+            let optionsDiv = this.getContainerOptions().systemStatusContainer;
+            if (optionsDiv) {
+                this.systemStatusDiv =
+                    typeof optionsDiv === 'string' ? document.getElementById(optionsDiv) : optionsDiv;
+            }
+        }
+        if (this.systemStatusDiv) {
+            if (StringExtensions_1.default.IsNotNullOrEmpty(statusFurtherInformation)) {
+                statusMessage += statusFurtherInformation;
+            }
+            const foreColor = messageType ? UIHelper_1.default.getColorByMessageType(messageType) : 'black';
+            react_dom_1.render(react_1.createElement('span', { style: { color: foreColor } }, statusMessage), this.systemStatusDiv);
+        }
+    }
+    setErrorSystemStatus(statusMessage, statusFurtherInformation) {
+        this.setSystemStatus(statusMessage, 'Error', statusFurtherInformation);
+    }
+    setWarningSystemStatus(statusMessage, statusFurtherInformation) {
+        this.setSystemStatus(statusMessage, 'Warning', statusFurtherInformation);
+    }
+    setSuccessSystemStatus(statusMessage, statusFurtherInformation) {
+        this.setSystemStatus(statusMessage, 'Success', statusFurtherInformation);
+    }
+    setInfoSystemStatus(statusMessage, statusFurtherInformation) {
+        this.setSystemStatus(statusMessage, 'Info', statusFurtherInformation);
+    }
+    setDefaultMessage() {
+        LoggingHelper_1.LogAdaptableWarning(`SystemStatusApi.setDefaultMessage is deprecated`);
+    }
+    showSystemStatusPopup() {
+        this.showModulePopup(ModuleConstants.SystemStatusModuleId);
+    }
+    fireSystemStatusMessageDisplayedEvent(systemStatusMessageInfo) {
+        const systemStatusMessageDisplayedInfo = {
+            systemStatusMessageInfo: systemStatusMessageInfo,
+        };
+        this.adaptable.api.eventApi.emit('SystemStatusMessageDisplayed', systemStatusMessageDisplayedInfo);
+    }
+    getCurrentSystemStatusMessageInfo() {
+        const messageInfos = this.adaptable.api.internalApi.getSystemStatusMessageInfos() || [];
+        const orderedArray = messageInfos.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return orderedArray[0];
+    }
+    deleteAllSystemStatusMessages() {
+        this.dispatchAction(SystemRedux.SystemStatusMessageInfoDeleteAll());
+    }
+}
+exports.SystemStatusApiImpl = SystemStatusApiImpl;

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

@@ -0,0 +1,12 @@
+import { ApiBase } from './ApiBase';
+import { TeamSharingApi } from '../TeamSharingApi';
+import { TeamSharingState, SharedEntity } from '../../types';
+export declare class TeamSharingApiImpl extends ApiBase implements TeamSharingApi {
+    getTeamSharingState(): TeamSharingState;
+    getSharedEntities(): SharedEntity[];
+    isTeamSharingActivated(): boolean;
+    hasTeamSharingFullRights(): boolean;
+    checkForUpdates(): void;
+    showTeamSharingPopup(): void;
+    fireTeamSharedEntityChangedInfoEvent(sharedEntity: SharedEntity): void;
+}

package/src/Api/Implementation/TeamSharingApiImpl.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamSharingApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ApiBase_1 = require("./ApiBase");
+const TeamSharingRedux_1 = require("../../Redux/ActionsReducers/TeamSharingRedux");
+class TeamSharingApiImpl extends ApiBase_1.ApiBase {
+    getTeamSharingState() {
+        return this.getAdaptableState().TeamSharing;
+    }
+    getSharedEntities() {
+        return this.getAdaptableState().TeamSharing.SharedEntities;
+    }
+    isTeamSharingActivated() {
+        return (!this.adaptable.api.internalApi
+            .getEntitlementService()
+            .isModuleHiddenEntitlement(ModuleConstants.TeamSharingModuleId) &&
+            this.adaptable.adaptableOptions.teamSharingOptions &&
+            this.adaptable.adaptableOptions.teamSharingOptions.enableTeamSharing &&
+            !!this.adaptable.adaptableOptions.teamSharingOptions.getSharedEntities &&
+            !!this.adaptable.adaptableOptions.teamSharingOptions.setSharedEntities);
+    }
+    hasTeamSharingFullRights() {
+        return this.adaptable.api.internalApi
+            .getEntitlementService()
+            .isModuleFullEntitlement(ModuleConstants.TeamSharingModuleId);
+    }
+    checkForUpdates() {
+        this.dispatchAction(TeamSharingRedux_1.TeamSharingCheckForUpdates());
+    }
+    showTeamSharingPopup() {
+        this.showModulePopup(ModuleConstants.TeamSharingModuleId);
+    }
+    fireTeamSharedEntityChangedInfoEvent(sharedEntity) {
+        if (this.adaptable.isInitialised) {
+            const teamSharedEntityChangedInfo = {
+                sharedEntity: sharedEntity,
+            };
+            this.adaptable.api.eventApi.emit('TeamSharedEntityChanged', teamSharedEntityChangedInfo);
+        }
+    }
+}
+exports.TeamSharingApiImpl = TeamSharingApiImpl;

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

@@ -0,0 +1,17 @@
+import { ApiBase } from './ApiBase';
+import { ThemeApi } from '../ThemeApi';
+import { ThemeState, AdaptableTheme } from '../../PredefinedConfig/ThemeState';
+export declare class ThemeApiImpl extends ApiBase implements ThemeApi {
+    getThemeState(): ThemeState;
+    loadTheme(theme: string): void;
+    loadLightTheme(): void;
+    loadDarkTheme(): void;
+    getCurrentTheme(): string;
+    setSystemThemes(systemThemes: AdaptableTheme[]): void;
+    setUserThemes(userThemes: AdaptableTheme[]): void;
+    getAllSystemTheme(): AdaptableTheme[];
+    applyCurrentTheme(): void;
+    getAllUserTheme(): AdaptableTheme[];
+    getAllTheme(): AdaptableTheme[];
+    showThemePopup(): void;
+}

package/src/Api/Implementation/ThemeApiImpl.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ThemeRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ThemeRedux"));
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ApiBase_1 = require("./ApiBase");
+class ThemeApiImpl extends ApiBase_1.ApiBase {
+    getThemeState() {
+        return this.getAdaptableState().Theme;
+    }
+    loadTheme(theme) {
+        this.dispatchAction(ThemeRedux.ThemeSelect(theme));
+    }
+    loadLightTheme() {
+        this.loadTheme('light');
+    }
+    loadDarkTheme() {
+        this.loadTheme('dark');
+    }
+    getCurrentTheme() {
+        return this.getAdaptableState().Theme.CurrentTheme;
+    }
+    setSystemThemes(systemThemes) {
+        this.dispatchAction(ThemeRedux.ThemeSetSystemThemes(systemThemes));
+    }
+    setUserThemes(userThemes) {
+        this.dispatchAction(ThemeRedux.ThemeSetUserThemes(userThemes));
+    }
+    getAllSystemTheme() {
+        const themes = this.getAdaptableState().Theme.SystemThemes;
+        return themes.map((theme) => {
+            if (typeof theme === 'string') {
+                return {
+                    Name: theme,
+                    Description: theme,
+                };
+            }
+            return theme;
+        });
+    }
+    applyCurrentTheme() {
+        const currentTheme = this.getAllTheme().filter((theme) => typeof theme === 'string'
+            ? theme === this.getCurrentTheme()
+            : theme.Name === this.getCurrentTheme())[0];
+        if (!currentTheme) {
+            return;
+        }
+        this.adaptable.applyAdaptableTheme(currentTheme);
+        let themeChangedInfo = {
+            theme: currentTheme,
+        };
+        this.adaptable.api.eventApi.emit('ThemeChanged', themeChangedInfo);
+    }
+    getAllUserTheme() {
+        return this.getAdaptableState().Theme.UserThemes;
+    }
+    getAllTheme() {
+        return [...this.getAllSystemTheme(), ...this.getAllUserTheme()];
+    }
+    showThemePopup() {
+        this.showModulePopup(ModuleConstants.ThemeModuleId);
+    }
+}
+exports.ThemeApiImpl = ThemeApiImpl;

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

@@ -0,0 +1,20 @@
+import { ApiBase } from './ApiBase';
+import { ToolPanelApi } from '../ToolPanelApi';
+import { ToolPanelState, ToolPanelVisibilityMode } from '../../PredefinedConfig/ToolPanelState';
+import { CustomToolPanel, ToolPanelButtonContext } from '../../AdaptableOptions/ToolPanelOptions';
+import { AdaptableButton } from '../../PredefinedConfig/Common/AdaptableButton';
+import { ModuleParams } from '../../View/Components/SharedProps/ModuleViewPopupProps';
+import { AdaptableToolPanel } from '../../PredefinedConfig/Common/Types';
+export declare class ToolPanelApiImpl extends ApiBase implements ToolPanelApi {
+    getToolPanelState(): ToolPanelState;
+    showToolPanelPopup(popupParams?: ModuleParams): void;
+    openAdapTableToolPanel(): void;
+    closeAdapTableToolPanel(): void;
+    getCustomToolPanels(): CustomToolPanel[];
+    getCustomToolPanelButtons(): AdaptableButton<ToolPanelButtonContext>[];
+    getCustomToolPanelByName(name: string): CustomToolPanel | undefined;
+    setAdaptableToolPanelVisibilityMode(adaptableToolPanel: AdaptableToolPanel, visibilityMode: ToolPanelVisibilityMode): void;
+    setCustomToolPanelVisibilityMode(customToolPanelName: string, visibilityMode: ToolPanelVisibilityMode): void;
+    private setExpandedToolPanelVisibility;
+    private setCollapsedToolPanelVisibility;
+}

package/src/Api/Implementation/ToolPanelApiImpl.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPanelApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("./ApiBase");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ToolPanelRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ToolPanelRedux"));
+class ToolPanelApiImpl extends ApiBase_1.ApiBase {
+    getToolPanelState() {
+        return this.getAdaptableState().ToolPanel;
+    }
+    showToolPanelPopup(popupParams) {
+        this.showModulePopup(ModuleConstants.ToolPanelModuleId, popupParams);
+    }
+    openAdapTableToolPanel() {
+        let gridOptions = this.getOptions().vendorGrid;
+        if (gridOptions) {
+            gridOptions.api.openToolPanel('AdaptableToolPanel');
+        }
+    }
+    closeAdapTableToolPanel() {
+        let gridOptions = this.getOptions().vendorGrid;
+        if (gridOptions) {
+            gridOptions.api.closeToolPanel();
+        }
+    }
+    getCustomToolPanels() {
+        var _a;
+        return (_a = this.getToolPanelOptions().customToolPanels) !== null && _a !== void 0 ? _a : [];
+    }
+    getCustomToolPanelButtons() {
+        var _a;
+        return (_a = this.getToolPanelOptions().customToolPanelButtons) !== null && _a !== void 0 ? _a : [];
+    }
+    getCustomToolPanelByName(name) {
+        return this.getCustomToolPanels().find((customToolPanel) => customToolPanel.name === name);
+    }
+    setAdaptableToolPanelVisibilityMode(adaptableToolPanel, visibilityMode) {
+        if (visibilityMode === 'expanded') {
+            this.setExpandedToolPanelVisibility(adaptableToolPanel);
+        }
+        else {
+            this.setCollapsedToolPanelVisibility(adaptableToolPanel);
+        }
+    }
+    setCustomToolPanelVisibilityMode(customToolPanelName, visibilityMode) {
+        if (visibilityMode === 'expanded') {
+            this.setExpandedToolPanelVisibility(customToolPanelName);
+        }
+        else {
+            this.setCollapsedToolPanelVisibility(customToolPanelName);
+        }
+    }
+    setExpandedToolPanelVisibility(toolPanelName) {
+        this.dispatchAction(ToolPanelRedux.ToolPanelExpandToolPanel(toolPanelName));
+    }
+    setCollapsedToolPanelVisibility(toolPanelName) {
+        this.dispatchAction(ToolPanelRedux.ToolPanelCollapseToolPanel(toolPanelName));
+    }
+}
+exports.ToolPanelApiImpl = ToolPanelApiImpl;

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

@@ -0,0 +1,24 @@
+import { ApiBase } from './ApiBase';
+import { UserInterfaceApi } from '../UserInterfaceApi';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableStyle } from '../../PredefinedConfig/Common/AdaptableStyle';
+import { UserMenuItem } from '../../PredefinedConfig/Common/Menu';
+import { ActionColumn, CellValuesList } from '../../AdaptableOptions/UserInterfaceOptions';
+export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfaceApi {
+    getColorPalette(): string[];
+    getStyleClassNames(): string[] | undefined;
+    getAllPermittedValuesItems(): CellValuesList[];
+    private getPermittedValuesItemsWithColumnScope;
+    private getPermittedValuesItemsWithDataTypeScope;
+    private getPermittedValuesItemsWithAllScope;
+    private getPermittedValuesForScope;
+    getPermittedValuesForColumn(column: AdaptableColumn): any[] | undefined;
+    getAllEditLookUpItems(): CellValuesList[];
+    getEditLookUpItemForColumn(columnId: string): CellValuesList | undefined;
+    getEditLookUpValuesForEditLookUpItem(editLookUpItem: CellValuesList, columnId: string): any[] | undefined;
+    addColumnMenuItem(columnMenuItem: UserMenuItem): void;
+    addContextMenuItem(contextMenuItem: UserMenuItem): void;
+    getEditableCellStyle(): AdaptableStyle | undefined;
+    getReadOnlyCellStyle(): AdaptableStyle | undefined;
+    getAllActionColumn(): ActionColumn[];
+}

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserInterfaceApiImpl = void 0;
+const ApiBase_1 = require("./ApiBase");
+const ArrayExtensions_1 = require("../../Utilities/Extensions/ArrayExtensions");
+class UserInterfaceApiImpl extends ApiBase_1.ApiBase {
+    getColorPalette() {
+        let colorPalette = this.getUserInterfaceOptions().colorPalette;
+        // first do the function then get hardcoded items
+        if (colorPalette != null && typeof colorPalette === 'function') {
+            return colorPalette();
+        }
+        else {
+            let arr = colorPalette;
+            if (arr && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(arr)) {
+                return arr;
+            }
+        }
+        return [];
+    }
+    getStyleClassNames() {
+        return this.getUserInterfaceOptions().styleClassNames;
+    }
+    getAllPermittedValuesItems() {
+        return this.getUserInterfaceOptions().permittedValues;
+    }
+    getPermittedValuesItemsWithColumnScope() {
+        return this.getAllPermittedValuesItems().filter((pv) => {
+            return 'ColumnIds' in pv.scope == true;
+        });
+    }
+    getPermittedValuesItemsWithDataTypeScope() {
+        return this.getAllPermittedValuesItems().filter((pv) => {
+            return 'DataTypes' in pv.scope == true;
+        });
+    }
+    getPermittedValuesItemsWithAllScope() {
+        return this.getAllPermittedValuesItems().filter((pv) => {
+            return 'All' in pv.scope == true;
+        });
+    }
+    getPermittedValuesForScope(column) {
+        let permittedValuesItem;
+        this.getPermittedValuesItemsWithColumnScope().forEach((pv) => {
+            if (!permittedValuesItem) {
+                if (this.adaptable.api.scopeApi.isColumnInScope(column, pv.scope)) {
+                    permittedValuesItem = pv;
+                }
+            }
+        });
+        if (permittedValuesItem) {
+            return permittedValuesItem;
+        }
+        this.getPermittedValuesItemsWithDataTypeScope().forEach((pv) => {
+            if (!permittedValuesItem) {
+                if (this.adaptable.api.scopeApi.isColumnInScope(column, pv.scope)) {
+                    permittedValuesItem = pv;
+                }
+            }
+        });
+        if (permittedValuesItem) {
+            return permittedValuesItem;
+        }
+        this.getPermittedValuesItemsWithAllScope().forEach((pv) => {
+            if (!permittedValuesItem) {
+                if (this.adaptable.api.scopeApi.isColumnInScope(column, pv.scope)) {
+                    permittedValuesItem = pv;
+                }
+            }
+        });
+        if (permittedValuesItem) {
+            return permittedValuesItem;
+        }
+        return undefined;
+    }
+    getPermittedValuesForColumn(column) {
+        if (ArrayExtensions_1.ArrayExtensions.IsNullOrEmpty(this.getAllPermittedValuesItems())) {
+            return undefined;
+        }
+        let permittedValuesColumn = this.getPermittedValuesForScope(column);
+        if (!permittedValuesColumn) {
+            return undefined;
+        }
+        let permittedValues = permittedValuesColumn.values;
+        // first do the function then get hardcoded items
+        if (permittedValues != null && typeof permittedValues === 'function') {
+            if (column) {
+                return permittedValues(column);
+            }
+        }
+        else {
+            let arr = permittedValues;
+            if (arr && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(arr)) {
+                return arr;
+            }
+        }
+        return undefined;
+    }
+    getAllEditLookUpItems() {
+        return this.getUserInterfaceOptions().editLookUpItems;
+    }
+    getEditLookUpItemForColumn(columnId) {
+        const abColumn = this.adaptable.api.columnApi.getColumnFromId(columnId);
+        if (!abColumn) {
+            return undefined;
+        }
+        let editLookUpItem;
+        let editLookUpItems = this.getAllEditLookUpItems();
+        if (!editLookUpItems) {
+            return undefined;
+        }
+        // first we get any for the column as that is lower level
+        const columnEditLookItems = editLookUpItems.filter((pv) => {
+            return 'ColumnIds' in pv.scope == true;
+        });
+        columnEditLookItems.forEach((eli) => {
+            if (this.adaptable.api.scopeApi.isColumnInScopeColumns(abColumn, eli.scope)) {
+                editLookUpItem = eli;
+            }
+        });
+        if (editLookUpItem) {
+            return editLookUpItem;
+        }
+        // then we get any for the DataType
+        const dateEditLookItems = editLookUpItems.filter((pv) => {
+            return 'DataTypes' in pv.scope == true;
+        });
+        dateEditLookItems.forEach((eli) => {
+            if (this.adaptable.api.scopeApi.isColumnInDateScope(abColumn, eli.scope)) {
+                editLookUpItem = eli;
+            }
+        });
+        if (editLookUpItem) {
+            return editLookUpItem;
+        }
+        // then we get any for All
+        const allTypeEditLookItems = editLookUpItems.filter((pv) => {
+            return 'All' in pv.scope == true;
+        });
+        allTypeEditLookItems.forEach((eli) => {
+            if (this.adaptable.api.scopeApi.isColumnInScope(abColumn, eli.scope)) {
+                editLookUpItem = eli;
+            }
+        });
+        if (editLookUpItem) {
+            return editLookUpItem;
+        }
+        return undefined;
+    }
+    getEditLookUpValuesForEditLookUpItem(editLookUpItem, columnId) {
+        if (!editLookUpItem) {
+            return undefined;
+        }
+        const column = this.adaptable.api.columnApi.getColumnFromId(columnId);
+        if (!column) {
+            return undefined;
+        }
+        let editLookUpValues = editLookUpItem.values;
+        // first do the function then get hardcoded items
+        if (editLookUpValues != null && typeof editLookUpValues === 'function') {
+            return editLookUpValues(column);
+        }
+        else {
+            let arr = editLookUpValues;
+            if (arr && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(arr)) {
+                return arr;
+            }
+        }
+        // if no hard-coded values or function provided then just get the distinct values for the column
+        // this will use the columnapi method that first looks for permitted values and then distinct values
+        return this.adaptable.api.columnApi.getDistinctDisplayValuesForColumn(columnId);
+    }
+    addColumnMenuItem(columnMenuItem) {
+        var _a;
+        (_a = this.getMenuOptions().columnMenuItems) === null || _a === void 0 ? void 0 : _a.push(columnMenuItem);
+    }
+    addContextMenuItem(contextMenuItem) {
+        var _a;
+        (_a = this.getMenuOptions().contextMenuItems) === null || _a === void 0 ? void 0 : _a.push(contextMenuItem);
+    }
+    getEditableCellStyle() {
+        return this.getUserInterfaceOptions().editableCellStyle;
+    }
+    getReadOnlyCellStyle() {
+        return this.getUserInterfaceOptions().readOnlyCellStyle;
+    }
+    getAllActionColumn() {
+        var _a;
+        return (_a = this.getUserInterfaceOptions().actionColumns) !== null && _a !== void 0 ? _a : [];
+    }
+}
+exports.UserInterfaceApiImpl = UserInterfaceApiImpl;

package/src/Api/InternalApi.d.ts

@@ -0,0 +1,117 @@
+import { UIConfirmation } from '../Utilities/Interface/MessagePopups';
+import { SystemState } from '../PredefinedConfig/SystemState';
+import { ChartData } from '../PredefinedConfig/ChartState';
+import { ChartVisibility } from '../PredefinedConfig/Common/ChartEnums';
+import { Action } from 'redux';
+import { ModuleParams } from '../View/Components/SharedProps/ModuleViewPopupProps';
+import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
+import { SelectedCellInfo } from '../PredefinedConfig/Selection/SelectedCellInfo';
+import { SelectedRowInfo } from '../PredefinedConfig/Selection/SelectedRowInfo';
+import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+import { GridCell } from '../PredefinedConfig/Selection/GridCell';
+import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
+import { IValidationService } from '../Utilities/Services/Interface/IValidationService';
+import { IModuleService } from '../Utilities/Services/Interface/IModuleService';
+import { IReportService } from '../Utilities/Services/Interface/IReportService';
+import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
+import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
+import { Layout } from '../PredefinedConfig/LayoutState';
+import { ServerSearchOption } from '../AdaptableOptions/SearchOptions';
+import { AdaptableAlert } from '../PredefinedConfig/Common/AdaptableAlert';
+import { IDataService } from '../Utilities/Services/Interface/IDataService';
+import { AdaptableMessageType, DataChangedInfo, SystemStatusMessageInfo } from '../types';
+import { IEntitlementService } from '../Utilities/Services/Interface/IEntitlementService';
+import { AdaptableFlashingAlert } from '../PredefinedConfig/Common/AdaptableFlashingAlert';
+import { IExpressionService } from '../Utilities/Services/Interface/IExpressionService';
+import { IAlertService } from '../Utilities/Services/Interface/IAlertService';
+import { AdaptableState } from '../PredefinedConfig/AdaptableState';
+import { ITeamSharingService } from '../Utilities/Services/Interface/ITeamSharingService';
+import { AdaptableButton, ButtonContext } from '../PredefinedConfig/Common/AdaptableButton';
+import { ColumnSortComparer } from '../AdaptableOptions/GeneralOptions';
+import { ButtonStyle } from '../PredefinedConfig/Common/ButtonStyle';
+import { AdaptableForm } from '../PredefinedConfig/Common/AdaptableForm';
+import { AlertButtonForm } from '../PredefinedConfig/AlertState';
+import { AdaptableFrameworkComponent } from '../AdaptableOptions/AdaptableFrameworkComponent';
+import { IMetamodelService } from '../Utilities/Services/Interface/IMetamodelService';
+/**
+ * This set of api methods is designed for **internal use of Adaptable** only.
+ *
+ * None of these methods should be invoked by users of Adaptable and no guarantee is made regarding performance or any after affects if used 'externally'.
+ */
+export interface InternalApi {
+    getSystemState(): SystemState;
+    getAdaptableFormFromAlertForm(alertForm: string | AlertButtonForm, context: any, defaultMessageType?: AdaptableMessageType): Omit<AdaptableForm<ButtonContext>, 'buttons'> & {
+        buttons?: (Omit<AdaptableButton<ButtonContext>, 'buttonStyle'> & {
+            buttonStyle?: ButtonStyle;
+        })[];
+    };
+    setChartData(chartData: ChartData): void;
+    setChartVisibility(chartVisbility: ChartVisibility): void;
+    getAdaptableAlerts(): AdaptableAlert[];
+    showPopupConfirmation(confirmation: UIConfirmation): void;
+    getAdaptableFlashingAlertFor(primaryKey: string, columnId?: string): AdaptableFlashingAlert | null;
+    addSystemStatusMessageInfo(systemStatusMessageInfo: SystemStatusMessageInfo): void;
+    getSystemStatusMessageInfos(): SystemStatusMessageInfo[];
+    showLoadingScreen(): void;
+    hideLoadingScreen(): void;
+    showPopupScreen(module: AdaptableModule, componentName: string, popupParams?: ModuleParams, popupProps?: {
+        [key: string]: any;
+    }): void;
+    isDocumentationLinksDisplayed(): boolean;
+    hidePopupScreen(): void;
+    hidePopupAlert(): void;
+    setColumns(columns: AdaptableColumn[]): void;
+    setModuleDropdownMenuItems(menuItems: AdaptableMenuItem[]): void;
+    setModuleButtonMenuItems(menuItems: AdaptableMenuItem[]): void;
+    setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
+    setSelectedRows(selectedRowInfo: SelectedRowInfo): void;
+    setPivotModeOn(): void;
+    setPivotModeOff(): void;
+    isGridInPivotMode(): boolean;
+    setTreeModeOn(): void;
+    setTreeModeOff(): void;
+    isGridInTreeMode(): boolean;
+    addAdaptableColumn(AdaptableColumn: AdaptableColumn): void;
+    removeAdaptableColumn(colId: string): void;
+    setGridCells(gridCells: GridCell[]): void;
+    setGridCell(gridCell: GridCell): void;
+    setToolbarTitle(): string;
+    getQueryPreviewData(): any;
+    buildDataChangedInfo(config: Pick<DataChangedInfo, 'newValue' | 'oldValue' | 'columnId' | 'primaryKeyValue' | 'rowNode' | 'trigger'>): DataChangedInfo;
+    setLastAppliedShortCut(gridCell: GridCell | undefined): void;
+    setDefaultDashboardTab(): void;
+    updateCurrentDraftLayout(layout: Layout): void;
+    getPrimaryKey(): any;
+    getAdaptableInstance(): IAdaptable;
+    getVendorGridInstance(): any;
+    getPredefinedConfig(): any;
+    getState(): AdaptableState;
+    getAdaptableOptions(): AdaptableOptions;
+    getValidationService(): IValidationService;
+    getModuleService(): IModuleService;
+    getReportService(): IReportService;
+    getDataService(): IDataService;
+    getCalculatedColumnExpressionService(): ICalculatedColumnExpressionService;
+    getEntitlementService(): IEntitlementService;
+    getExpressionService(): IExpressionService;
+    getAlertService(): IAlertService;
+    getTeamSharingService(): ITeamSharingService;
+    getMetamodelService(): IMetamodelService;
+    getModuleFriendlyName(adaptableModule: AdaptableModule): string;
+    isServerSearchOptionSet(serverSearchOption: ServerSearchOption): boolean;
+    buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
+    getCustomSortComparer(column: AdaptableColumn): ColumnSortComparer | undefined;
+    clearFlashingCellState(): void;
+    clearUpdatedRowState(): void;
+    clearGradientColumnState(): void;
+    clearPercentBarState(): void;
+    getLabelForButton(button: AdaptableButton<ButtonContext>, context: ButtonContext): string | undefined;
+    getTooltipForButton(button: AdaptableButton<ButtonContext>, context: ButtonContext): string | undefined;
+    getStyleForButton(button: AdaptableButton<ButtonContext>, context: ButtonContext): ButtonStyle | undefined;
+    dispatchReduxAction(action: Action): void;
+    waitForTeamSharingImportEnd(): Promise<boolean>;
+    getUserDefinedHeaderName(columnId: string): string;
+    createFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar'): void;
+    destroyFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar'): void;
+}

package/src/Api/InternalApi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });