@adaptabletools/adaptable 10.0.0-canary.0

package/src/Api/Implementation/ConditionalStyleApiImpl.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalStyleApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("./ApiBase");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const ConditionalStyleRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ConditionalStyleRedux"));
+class ConditionalStyleApiImpl extends ApiBase_1.ApiBase {
+    getConditionalStyleState() {
+        return this.getAdaptableState().ConditionalStyle;
+    }
+    getAllConditionalStyle() {
+        return this.getConditionalStyleState().ConditionalStyles;
+    }
+    getAllActiveConditionalStyle() {
+        return this.getAllConditionalStyle().filter((style) => !style.IsSuspended);
+    }
+    getConditionalStyleById(id) {
+        var _a;
+        return (_a = this.getAllConditionalStyle()) === null || _a === void 0 ? void 0 : _a.find((conditionalStyle) => (conditionalStyle === null || conditionalStyle === void 0 ? void 0 : conditionalStyle.Uuid) === id);
+    }
+    getAllSuspendedConditionalStyle() {
+        return this.getAllConditionalStyle().filter((style) => style.IsSuspended);
+    }
+    editConditionalStyle(conditionalStyle) {
+        this.dispatchAction(ConditionalStyleRedux.ConditionalStyleEdit(conditionalStyle));
+        return this.getConditionalStyleById(conditionalStyle.Uuid);
+    }
+    editConditionalStyles(conditionalStyles) {
+        conditionalStyles.forEach((cs) => {
+            this.editConditionalStyle(cs);
+        });
+        return conditionalStyles === null || conditionalStyles === void 0 ? void 0 : conditionalStyles.map((conditionalStyle) => this.getConditionalStyleById(conditionalStyle.Uuid));
+    }
+    addConditionalStyle(conditionalStyle) {
+        this.addUidToAdaptableObject(conditionalStyle);
+        this.dispatchAction(ConditionalStyleRedux.ConditionalStyleAdd(conditionalStyle));
+        return this.getConditionalStyleById(conditionalStyle.Uuid);
+    }
+    showConditionalStylePopup() {
+        this.showModulePopup(ModuleConstants.ConditionalStyleModuleId);
+    }
+    getRowConditionalStyles() {
+        return this.getAllConditionalStyle().filter((cs) => this.adaptable.api.scopeApi.scopeIsAll(cs.Scope));
+    }
+    getConditionalStylesWithExpression() {
+        return this.getAllConditionalStyle().filter((cs) => !!cs.Rule.BooleanExpression);
+    }
+    getColumnConditionalStyles() {
+        return this.getAllConditionalStyle().filter((cs) => !this.adaptable.api.scopeApi.scopeIsAll(cs.Scope));
+    }
+    getOrderedConditionalStyles() {
+        const colConditionalStyles = this.getColumnConditionalStyles();
+        let orderedConditionalStyles = this.getRowConditionalStyles()
+            .concat(this.getConditionalStylesWithDataTypeScope(colConditionalStyles))
+            .concat(this.getConditionalStylesWithColumnScope(colConditionalStyles));
+        return orderedConditionalStyles;
+    }
+    getConditionalStylesForColumn(column) {
+        const colConditionalStyles = this.getColumnConditionalStyles();
+        let returnStyles = [];
+        colConditionalStyles.forEach((fc) => {
+            if (this.adaptable.api.scopeApi.isColumnInScope(column, fc.Scope)) {
+                returnStyles.push(fc);
+            }
+        });
+        return returnStyles;
+    }
+    getConditionalStylesWithDataTypeScope(conditionalStyles) {
+        return conditionalStyles.filter((fc) => this.adaptable.api.scopeApi.scopeHasDataType(fc.Scope));
+    }
+    getConditionalStylesWithColumnScope(conditionalStyles) {
+        return conditionalStyles.filter((fc) => this.adaptable.api.scopeApi.scopeHasColumns(fc.Scope));
+    }
+    getConditionalStylePredicateDefs() {
+        return this.adaptable.api.predicateApi.getPredicateDefsByModuleScope('conditionalstyle');
+    }
+    getCondStylePredicateDefsForScope(scope) {
+        return this.getConditionalStylePredicateDefs().filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    }
+    suspendConditionalStyle(conditionalStyle) {
+        this.dispatchAction(ConditionalStyleRedux.ConditionalStyleSuspend(conditionalStyle));
+        return this.getConditionalStyleById(conditionalStyle.Uuid);
+    }
+    unSuspendConditionalStyle(conditionalStyle) {
+        this.dispatchAction(ConditionalStyleRedux.ConditionalStyleUnSuspend(conditionalStyle));
+        return this.getConditionalStyleById(conditionalStyle.Uuid);
+    }
+}
+exports.ConditionalStyleApiImpl = ConditionalStyleApiImpl;

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

@@ -0,0 +1,73 @@
+import { ChartState } from '../../PredefinedConfig/ChartState';
+import { ThemeState } from '../../PredefinedConfig/ThemeState';
+import { ShortcutState } from '../../PredefinedConfig/ShortcutState';
+import { QuickSearchState } from '../../PredefinedConfig/QuickSearchState';
+import { PlusMinusState } from '../../PredefinedConfig/PlusMinusState';
+import { LayoutState } from '../../PredefinedConfig/LayoutState';
+import { FormatColumnState } from '../../PredefinedConfig/FormatColumnState';
+import { ExportState } from '../../PredefinedConfig/ExportState';
+import { DataSourceState } from '../../PredefinedConfig/DataSourceState';
+import { DashboardState } from '../../PredefinedConfig/DashboardState';
+import { CustomSortState } from '../../PredefinedConfig/CustomSortState';
+import { ConditionalStyleState } from '../../PredefinedConfig/ConditionalStyleState';
+import { CalculatedColumnState } from '../../PredefinedConfig/CalculatedColumnState';
+import { AlertState } from '../../PredefinedConfig/AlertState';
+import { ConfigState } from '../../PredefinedConfig/ConfigState';
+import { AdaptableState } from '../../PredefinedConfig/AdaptableState';
+import { ApiBase } from './ApiBase';
+import { ApplicationState } from '../../PredefinedConfig/ApplicationState';
+import { SparklineColumnState } from '../../PredefinedConfig/SparklineColumnState';
+import { FreeTextColumnState } from '../../PredefinedConfig/FreeTextColumnState';
+import { FilterState } from '../../PredefinedConfig/FilterState';
+import { ToolPanelState } from '../../PredefinedConfig/ToolPanelState';
+import { ConfigApi } from '../ConfigApi';
+import { AdaptableStateKey, AdaptableModule } from '../../PredefinedConfig/Common/Types';
+import { AdaptableSearchState, ScheduleState } from '../../types';
+import { AdaptableSortState } from '../Events/SearchChanged';
+import { QueryState } from '../../PredefinedConfig/QueryState';
+import { PredefinedConfig } from '../../PredefinedConfig/PredefinedConfig';
+export declare class ConfigApiImpl extends ApiBase implements ConfigApi {
+    configInit(): void;
+    copyAllStateToClipboard(): void;
+    copyUserStateToClipboard(): void;
+    getPredefinedConfig(): PredefinedConfig | any;
+    reloadPredefinedConfig(newPredefinedConfig?: PredefinedConfig): void;
+    getAllState(): AdaptableState;
+    private getUserStateKeys;
+    getAllUserState(): ConfigState[];
+    loadUserState(state: {
+        [s: string]: ConfigState;
+    }): void;
+    getAdaptableSearchState(): AdaptableSearchState;
+    getAdaptableSortState(): AdaptableSortState;
+    setAdaptableStateKey(adaptableStateKey: string, config?: {
+        predefinedConfig: PredefinedConfig;
+        flushCurrentState?: boolean;
+    }): PromiseLike<any>;
+    getDescriptionForModule(module: AdaptableModule): string;
+    getHelpPageForModule(module: AdaptableModule): string;
+    getUserStateByStateKey(stateKey: AdaptableStateKey, returnJson?: boolean): ConfigState | string;
+    incrementUerStateRevision(stateKey: AdaptableStateKey): void;
+    getAlertState(returnJson?: boolean): AlertState;
+    getApplicationState(returnJson?: boolean): ApplicationState;
+    getCalculatedColumnState(returnJson?: boolean): CalculatedColumnState;
+    getChartState(returnJson?: boolean): ChartState;
+    getConditionalStyleState(returnJson?: boolean): ConditionalStyleState;
+    getCustomSortState(returnJson?: boolean): CustomSortState;
+    getDashboardState(returnJson?: boolean): DashboardState;
+    getDataSourceState(returnJson?: boolean): DataSourceState;
+    getExportState(returnJson?: boolean): ExportState;
+    getFilterState(returnJson?: boolean): FilterState;
+    getFreeTextColumnState(returnJson?: boolean): FreeTextColumnState;
+    getFormatColumnState(returnJson?: boolean): FormatColumnState;
+    getLayoutState(returnJson?: boolean): LayoutState;
+    getPlusMinusState(returnJson?: boolean): PlusMinusState;
+    getQueryState(returnJson?: boolean): QueryState;
+    getQuickSearchState(returnJson?: boolean): QuickSearchState;
+    getScheduleState(returnJson?: boolean): ScheduleState;
+    getShortcutState(returnJson?: boolean): ShortcutState;
+    getSparklineColumnState(returnJson?: boolean): SparklineColumnState;
+    getThemeState(returnJson?: boolean): ThemeState;
+    getToolPanelState(returnJson?: boolean): ToolPanelState;
+    dispatchStateReadyAction(module: AdaptableModule): void;
+}

package/src/Api/Implementation/ConfigApiImpl.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigApiImpl = void 0;
+const tslib_1 = require("tslib");
+const AdaptableStore_1 = require("../../Redux/Store/AdaptableStore");
+const ApiBase_1 = require("./ApiBase");
+const Helper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/Helper"));
+const AdaptableHelper_1 = require("../../Utilities/Helpers/AdaptableHelper");
+const LayoutRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/LayoutRedux"));
+const DashboardRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/DashboardRedux"));
+const AlertRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/AlertRedux"));
+const BulkUpdateRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/BulkUpdateRedux"));
+const CalculatedColumnRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/CalculatedColumnRedux"));
+const ConditionalStyleRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ConditionalStyleRedux"));
+const CustomSortRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/CustomSortRedux"));
+const DataSourceRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/DataSourceRedux"));
+const ExportRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ExportRedux"));
+const FilterRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FilterRedux"));
+const FormatColumnRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FormatColumnRedux"));
+const FreeTextColumnRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/FreeTextColumnRedux"));
+const PlusMinusRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/PlusMinusRedux"));
+const QueryRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/QueryRedux"));
+const QuickSearchRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/QuickSearchRedux"));
+const ScheduleRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ScheduleRedux"));
+const ShortcutRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ShortcutRedux"));
+const SystemStatusRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemStatusRedux"));
+const SmartEditRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SmartEditRedux"));
+const ThemeRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ThemeRedux"));
+const ToolPanelRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/ToolPanelRedux"));
+class ConfigApiImpl extends ApiBase_1.ApiBase {
+    configInit() {
+        this.dispatchAction(AdaptableStore_1.InitState());
+    }
+    copyAllStateToClipboard() {
+        let state = this.getAdaptableState();
+        let stringifiedState = JSON.stringify(state);
+        Helper_1.default.copyToClipboard(stringifiedState);
+    }
+    copyUserStateToClipboard() {
+        // This doesnt currently work...
+        let state = this.getAdaptableState();
+        //  let userState = state
+        let stringifiedState = JSON.stringify(state);
+        Helper_1.default.copyToClipboard(stringifiedState);
+    }
+    getPredefinedConfig() {
+        return this.adaptable.adaptableOptions.predefinedConfig;
+    }
+    reloadPredefinedConfig(newPredefinedConfig) {
+        var _a;
+        const adaptableOptions = this.adaptable.adaptableOptions;
+        const clearStateFn = ((_a = adaptableOptions.stateOptions) === null || _a === void 0 ? void 0 : _a.clearState) ||
+            (() => {
+                localStorage.removeItem(adaptableOptions.adaptableStateKey);
+                return Promise.resolve(true);
+            });
+        this.adaptable.adaptableStore.saveStateNow(this.adaptable).then(() => {
+            const promise = clearStateFn({
+                adaptableId: adaptableOptions.adaptableId,
+                adaptableStateKey: adaptableOptions.adaptableStateKey,
+                userName: adaptableOptions.userName,
+            });
+            promise.then(() => {
+                this.setAdaptableStateKey(adaptableOptions.adaptableStateKey, {
+                    predefinedConfig: newPredefinedConfig || adaptableOptions.predefinedConfig,
+                    flushCurrentState: false,
+                });
+            });
+        });
+    }
+    getAllState() {
+        return this.getAdaptableState();
+    }
+    // im sure we can do this better
+    getUserStateKeys() {
+        return [
+            'Alert',
+            'Application',
+            'BulkUpdate',
+            'CalculatedColumn',
+            'CellSummary',
+            'Chart',
+            'ConditionalStyle',
+            'CustomSort',
+            'Dashboard',
+            'DataSource',
+            'Entitlement',
+            'Export',
+            'Filter',
+            'FormatColumn',
+            'FreeTextColumn',
+            'Layout',
+            'PlusMinus',
+            'Query',
+            'QuickSearch',
+            'Shortcut',
+            'SmartEdit',
+            'SparklineColumn',
+            'SystemStatus',
+            'Theme',
+            'ToolPanel',
+            'UserInterface',
+        ];
+    }
+    getAllUserState() {
+        const userStateKeys = this.getUserStateKeys();
+        const allState = this.getAllState();
+        return userStateKeys.map((k) => allState[k]);
+    }
+    loadUserState(state) {
+        const userStateKeys = this.getUserStateKeys();
+        const userState = Object.keys(state).reduce((xs, x) => (userStateKeys.indexOf(x) !== -1 ? Object.assign(Object.assign({}, xs), { [x]: state[x] }) : xs), {});
+        this.dispatchAction(AdaptableStore_1.LoadState(userState));
+    }
+    getAdaptableSearchState() {
+        const currentQuery = this.adaptable.api.queryApi.getCurrentQuery();
+        const adaptableSearchState = {
+            dataSource: this.adaptable.api.dataSourceApi.getCurrentDataSource(),
+            currentQuery,
+            queryAST: currentQuery ? this.adaptable.api.queryApi.getASTForQuery(currentQuery) : null,
+            columnFilters: this.adaptable.api.filterApi.getAllColumnFilter(),
+        };
+        return adaptableSearchState;
+    }
+    getAdaptableSortState() {
+        const adaptableSortState = {
+            columnSorts: this.adaptable.api.gridApi.getColumnSorts(),
+            customSorts: this.adaptable.api.customSortApi.getAllCustomSort(),
+        };
+        return adaptableSortState;
+    }
+    setAdaptableStateKey(adaptableStateKey, config) {
+        this.adaptable.adaptableOptions.adaptableStateKey = adaptableStateKey;
+        const flushCurrentState = !config || config.flushCurrentState !== false;
+        // make sure we persist any "pending" changes to state - since stateOptions.debounceStateDelay can cause
+        // the state to be persisted with a delay, which we dont want in this case
+        const flushStatePromise = flushCurrentState
+            ? this.adaptable.adaptableStore.saveStateNow(this.adaptable)
+            : Promise.resolve(true);
+        return flushStatePromise.then(() => {
+            let predefinedConfig = config === null || config === void 0 ? void 0 : config.predefinedConfig;
+            if (predefinedConfig) {
+                predefinedConfig = AdaptableHelper_1.initPredefinedConfigWithUuids(predefinedConfig);
+            }
+            const promise = this.adaptable.adaptableStore.loadStore(this.adaptable, adaptableStateKey, predefinedConfig);
+            promise.then(() => {
+                this.adaptable.prepareGrid();
+                this.adaptable.api.internalApi.hideLoadingScreen();
+            });
+            return promise;
+        });
+    }
+    getDescriptionForModule(module) {
+        return this.adaptable.ModuleService.getModuleInfoByModule(module).Description;
+    }
+    getHelpPageForModule(module) {
+        return this.adaptable.ModuleService.getModuleInfoByModule(module).HelpPage;
+    }
+    getUserStateByStateKey(stateKey, returnJson = false) {
+        switch (stateKey) {
+            case 'Alert':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Alert)
+                    : this.getAdaptableState().Alert;
+            case 'Application':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Application)
+                    : this.getAdaptableState().Application;
+            case 'BulkUpdate':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().BulkUpdate)
+                    : this.getAdaptableState().BulkUpdate;
+            case 'CalculatedColumn':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().CalculatedColumn)
+                    : this.getAdaptableState().CalculatedColumn;
+            case 'CellSummary':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().SelectedCells)
+                    : this.getAdaptableState().CellSummary;
+            case 'Chart':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Chart)
+                    : this.getAdaptableState().Chart;
+            case 'ConditionalStyle':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().ConditionalStyle)
+                    : this.getAdaptableState().ConditionalStyle;
+            case 'CustomSort':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().CustomSort)
+                    : this.getAdaptableState().CustomSort;
+            case 'Dashboard':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Dashboard)
+                    : this.getAdaptableState().Dashboard;
+            case 'DataSource':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().DataSource)
+                    : this.getAdaptableState().DataSource;
+            case 'Entitlement':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Entitlements)
+                    : this.getAdaptableState().Entitlements;
+            case 'Export':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Export)
+                    : this.getAdaptableState().Export;
+            case 'Filter':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Filter)
+                    : this.getAdaptableState().Filter;
+            case 'FormatColumn':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().FormatColumn)
+                    : this.getAdaptableState().FormatColumn;
+            case 'FreeTextColumn':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().FreeTextColumn)
+                    : this.getAdaptableState().FreeTextColumn;
+            case 'Layout':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Layout)
+                    : this.getAdaptableState().Layout;
+            case 'PlusMinus':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().PlusMinus)
+                    : this.getAdaptableState().PlusMinus;
+            case 'Query':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Query)
+                    : this.getAdaptableState().Query;
+            case 'QuickSearch':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().QuickSearch)
+                    : this.getAdaptableState().QuickSearch;
+            case 'Schedule':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Schedule)
+                    : this.getAdaptableState().Schedule;
+            case 'Shortcut':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Shortcut)
+                    : this.getAdaptableState().Shortcut;
+            case 'SmartEdit':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().SmartEdit)
+                    : this.getAdaptableState().SmartEdit;
+            case 'SparklineColumn':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().SparklineColumn)
+                    : this.getAdaptableState().SparklineColumn;
+            case 'SystemStatus':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().SystemStatus)
+                    : this.getAdaptableState().SystemStatus;
+            case 'Theme':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().Theme)
+                    : this.getAdaptableState().Theme;
+            case 'ToolPanel':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().ToolPanel)
+                    : this.getAdaptableState().ToolPanel;
+            case 'UserInterface':
+                return returnJson
+                    ? JSON.stringify(this.getAdaptableState().UserInterface)
+                    : this.getAdaptableState().UserInterface;
+        }
+    }
+    incrementUerStateRevision(stateKey) {
+        let state = this.getUserStateByStateKey(stateKey);
+        state.Revision += 1;
+        // need to save it...
+    }
+    getAlertState(returnJson = false) {
+        return this.getUserStateByStateKey('Alert', returnJson);
+    }
+    getApplicationState(returnJson = false) {
+        return this.getUserStateByStateKey('Application', returnJson);
+    }
+    getCalculatedColumnState(returnJson = false) {
+        return this.getUserStateByStateKey('CalculatedColumn', returnJson);
+    }
+    getChartState(returnJson = false) {
+        return this.getUserStateByStateKey('Chart', returnJson);
+    }
+    getConditionalStyleState(returnJson = false) {
+        return this.getUserStateByStateKey('ConditionalStyle', returnJson);
+    }
+    getCustomSortState(returnJson = false) {
+        return this.getUserStateByStateKey('CustomSort', returnJson);
+    }
+    getDashboardState(returnJson = false) {
+        return this.getUserStateByStateKey('Dashboard', returnJson);
+    }
+    getDataSourceState(returnJson = false) {
+        return this.getUserStateByStateKey('DataSource', returnJson);
+    }
+    getExportState(returnJson = false) {
+        return this.getUserStateByStateKey('Export', returnJson);
+    }
+    getFilterState(returnJson = false) {
+        return this.getUserStateByStateKey('Filter', returnJson);
+    }
+    getFreeTextColumnState(returnJson = false) {
+        return this.getUserStateByStateKey('FreeTextColumn', returnJson);
+    }
+    getFormatColumnState(returnJson = false) {
+        return this.getUserStateByStateKey('FormatColumn', returnJson);
+    }
+    getLayoutState(returnJson = false) {
+        return this.getUserStateByStateKey('Layout', returnJson);
+    }
+    getPlusMinusState(returnJson = false) {
+        return this.getUserStateByStateKey('PlusMinus', returnJson);
+    }
+    getQueryState(returnJson = false) {
+        return this.getUserStateByStateKey('Query', returnJson);
+    }
+    getQuickSearchState(returnJson = false) {
+        return this.getUserStateByStateKey('QuickSearch', returnJson);
+    }
+    getScheduleState(returnJson = false) {
+        return this.getUserStateByStateKey('Schedule', returnJson);
+    }
+    getShortcutState(returnJson = false) {
+        return this.getUserStateByStateKey('Shortcut', returnJson);
+    }
+    getSparklineColumnState(returnJson = false) {
+        return this.getUserStateByStateKey('SparklineColumn', returnJson);
+    }
+    getThemeState(returnJson = false) {
+        return this.getUserStateByStateKey('Theme', returnJson);
+    }
+    getToolPanelState(returnJson = false) {
+        return this.getUserStateByStateKey('ToolPanel', returnJson);
+    }
+    dispatchStateReadyAction(module) {
+        switch (module) {
+            case 'Alert':
+                this.dispatchAction(AlertRedux.AlertReady(this.getAlertState()));
+                break;
+            case 'BulkUpdate':
+                this.dispatchAction(BulkUpdateRedux.BulkUpdateReady());
+                break;
+            case 'CalculatedColumn':
+                this.dispatchAction(CalculatedColumnRedux.CalculatedColumnReady(this.getCalculatedColumnState()));
+                break;
+            case 'ConditionalStyle':
+                this.dispatchAction(ConditionalStyleRedux.ConditionalStyleReady(this.getConditionalStyleState()));
+                break;
+            case 'CustomSort':
+                this.dispatchAction(CustomSortRedux.CustomSortReady(this.getCustomSortState()));
+                break;
+            case 'Dashboard':
+                this.dispatchAction(DashboardRedux.DashboardReady(this.getDashboardState()));
+                break;
+            case 'DataSource':
+                this.dispatchAction(DataSourceRedux.DataSourceReady(this.getDataSourceState()));
+                break;
+            case 'Export':
+                this.dispatchAction(ExportRedux.ExportReady(this.getExportState()));
+                break;
+            case 'Filter':
+                this.dispatchAction(FilterRedux.FilterReady(this.getFilterState()));
+                break;
+            case 'FormatColumn':
+                this.dispatchAction(FormatColumnRedux.FormatColumnReady(this.getFormatColumnState()));
+                break;
+            case 'FreeTextColumn':
+                this.dispatchAction(FreeTextColumnRedux.FreeTextColumnReady(this.getFreeTextColumnState()));
+                break;
+            case 'Layout':
+                this.dispatchAction(LayoutRedux.LayoutReady(this.getLayoutState()));
+                break;
+            case 'PlusMinus':
+                this.dispatchAction(PlusMinusRedux.PlusMinusReady(this.getPlusMinusState()));
+                break;
+            case 'Query':
+                this.dispatchAction(QueryRedux.QueryReady(this.getQueryState()));
+                break;
+            case 'QuickSearch':
+                this.dispatchAction(QuickSearchRedux.QuickSearchReady(this.getQuickSearchState()));
+                break;
+            case 'Schedule':
+                this.dispatchAction(ScheduleRedux.ScheduleReady(this.getScheduleState()));
+                break;
+            case 'Shortcut':
+                this.dispatchAction(ShortcutRedux.ShortcutReady(this.getShortcutState()));
+                break;
+            case 'SmartEdit':
+                this.dispatchAction(SmartEditRedux.SmartEditReady());
+                break;
+            case 'SystemStatus':
+                this.dispatchAction(SystemStatusRedux.SystemStatusReady());
+                break;
+            case 'Theme':
+                this.dispatchAction(ThemeRedux.ThemeReady(this.getThemeState()));
+                break;
+            case 'ToolPanel':
+                this.dispatchAction(ToolPanelRedux.ToolPanelReady(this.getToolPanelState()));
+                break;
+        }
+    }
+}
+exports.ConfigApiImpl = ConfigApiImpl;

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

@@ -0,0 +1,18 @@
+import { ApiBase } from './ApiBase';
+import { CustomSortApi } from '../CustomSortApi';
+import { CustomSortState, CustomSort } from '../../PredefinedConfig/CustomSortState';
+export declare class CustomSortApiImpl extends ApiBase implements CustomSortApi {
+    getCustomSortState(): CustomSortState;
+    getAllCustomSort(): CustomSort[];
+    getCustomSortById(id: CustomSort['Uuid']): CustomSort;
+    getAllActiveCustomSort(): CustomSort[];
+    getAllSuspendedCustomSort(): CustomSort[];
+    getCustomSortByColumn(column: string): CustomSort;
+    addCustomSort(customSort: CustomSort): CustomSort;
+    createCustomSort(columnId: string, values: string[]): CustomSort;
+    editCustomSort(columnId: string, values: string[]): CustomSort;
+    deleteCustomSort(column: string): void;
+    suspendCustomSort(customSort: CustomSort): CustomSort;
+    unSuspendCustomSort(customSort: CustomSort): CustomSort;
+    showCustomSortPopup(): void;
+}

package/src/Api/Implementation/CustomSortApiImpl.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSortApiImpl = void 0;
+const tslib_1 = require("tslib");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+const CustomSortRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/CustomSortRedux"));
+const ApiBase_1 = require("./ApiBase");
+class CustomSortApiImpl extends ApiBase_1.ApiBase {
+    getCustomSortState() {
+        return this.getAdaptableState().CustomSort;
+    }
+    getAllCustomSort() {
+        return this.getAdaptableState().CustomSort.CustomSorts;
+    }
+    getCustomSortById(id) {
+        var _a;
+        return (_a = this.getAllCustomSort()) === null || _a === void 0 ? void 0 : _a.find((customSort) => customSort.Uuid === id);
+    }
+    getAllActiveCustomSort() {
+        return this.getAllCustomSort().filter((customSort) => !customSort.IsSuspended);
+    }
+    getAllSuspendedCustomSort() {
+        return this.getAllCustomSort().filter((customSort) => customSort.IsSuspended);
+    }
+    getCustomSortByColumn(column) {
+        return this.getAdaptableState().CustomSort.CustomSorts.find((cs) => cs.ColumnId == column);
+    }
+    addCustomSort(customSort) {
+        this.addUidToAdaptableObject(customSort);
+        this.dispatchAction(CustomSortRedux.CustomSortAdd(customSort));
+        return this.getCustomSortById(customSort.Uuid);
+    }
+    createCustomSort(columnId, values) {
+        let customSort = { ColumnId: columnId, SortedValues: values };
+        return this.addCustomSort(customSort);
+    }
+    editCustomSort(columnId, values) {
+        const previousCustomSort = this.getCustomSortByColumn(columnId);
+        if (!previousCustomSort) {
+            throw new TypeError(`No custom sort defined for ${columnId}`);
+        }
+        const newCustomSort = Object.assign(Object.assign({}, previousCustomSort), { SortedValues: values });
+        this.dispatchAction(CustomSortRedux.CustomSortEdit(newCustomSort));
+        return this.getCustomSortByColumn(columnId);
+    }
+    deleteCustomSort(column) {
+        let customSort = this.getCustomSortByColumn(column);
+        this.dispatchAction(CustomSortRedux.CustomSortDelete(customSort));
+    }
+    suspendCustomSort(customSort) {
+        this.dispatchAction(CustomSortRedux.CustomSortSuspend(customSort));
+        return this.getCustomSortById(customSort.Uuid);
+    }
+    unSuspendCustomSort(customSort) {
+        this.dispatchAction(CustomSortRedux.CustomSortUnSuspend(customSort));
+        return this.getCustomSortById(customSort.Uuid);
+    }
+    showCustomSortPopup() {
+        this.showModulePopup(ModuleConstants.CustomSortModuleId);
+    }
+}
+exports.CustomSortApiImpl = CustomSortApiImpl;