@tramvai/module-common 2.70.0 → 2.72.0

package/lib/actions/actionChecker.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('./constants.js');
+
+const DEFAULT_CONDITIONS = {};
+class ActionChecker {
+    // eslint-disable-next-line max-params
+    constructor(globalConditionals, payload, parameters, executionState, type) {
+        var _a;
+        this.globalConditionals = globalConditionals;
+        this.payload = payload;
+        this.parameters = parameters;
+        this.executionState = executionState;
+        this.type = type;
+        this.status = true;
+        this.forbiddenMarker = false;
+        this.key = null;
+        // для глобальных экшенов мы должны дедублицировать выполнение и меньше выполнять
+        if (type === constants.actionType.global) {
+            // если экшен был уже выполнен, то считаем, что его не нужно больше выполнять
+            this.status = executionState.status !== 'success';
+        }
+        this.conditions = (_a = parameters.conditions) !== null && _a !== void 0 ? _a : DEFAULT_CONDITIONS;
+    }
+    check() {
+        this.globalConditionals.forEach((filter) => {
+            this.key = filter.key;
+            filter.fn(this);
+        });
+        return this.getStatus();
+    }
+    setState(value) {
+        this.executionState.state[this.key] = value;
+    }
+    getState() {
+        return this.executionState.state[this.key];
+    }
+    forbid() {
+        this.executionState.status = 'forbidden';
+        this.executionState.forbiddenBy = this.key;
+        this.forbiddenMarker = true;
+    }
+    allow() {
+        this.status = true;
+    }
+    getStatus() {
+        if (this.forbiddenMarker) {
+            return false;
+        }
+        return this.status;
+    }
+}
+
+exports.ActionChecker = ActionChecker;

package/lib/actions/actionExecution.browser.js

@@ -0,0 +1,107 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import identity from '@tinkoff/utils/function/identity';
+import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+import objectMap from '@tinkoff/utils/object/map';
+import { ConditionFailError } from '@tinkoff/errors';
+import { ActionChecker } from './actionChecker.browser.js';
+import { actionType } from './constants.browser.js';
+import { actionTramvaiReducer } from './actionTramvaiReducer.browser.js';
+
+const EMPTY_DEPS = {};
+const DEFAULT_PAYLOAD = {};
+const getParameters = (action) => action[ACTION_PARAMETERS];
+class ActionExecution {
+    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+        this.actionConditionals = flatten(actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
+        this.context = context;
+        this.store = store;
+        this.di = di;
+        this.executionContextManager = executionContextManager;
+        this.execution = new Map();
+        this.transformAction = transformAction || identity;
+        const initialState = store.getState(actionTramvaiReducer);
+        if (initialState && initialState.serverState) {
+            objectMap((value, key) => {
+                this.execution.set(key, value);
+            }, initialState.serverState);
+        }
+    }
+    async runInContext(executionContext, action, ...params) {
+        var _a, _b;
+        let parameters;
+        const payload = (_a = params[0]) !== null && _a !== void 0 ? _a : DEFAULT_PAYLOAD;
+        // TODO: replace type with pure context usage
+        const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? actionType.global : actionType.local;
+        // TODO: remove else branch after migration to new declareAction
+        if (isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        const executionState = this.getExecutionState(parameters.name);
+        if (!this.canExecuteAction(payload, parameters, executionState, type)) {
+            switch (parameters.conditionsFailResult) {
+                case 'reject':
+                    return Promise.reject(new ConditionFailError({
+                        conditionName: (_b = executionState.forbiddenBy) !== null && _b !== void 0 ? _b : 'unknown',
+                        targetName: parameters.name,
+                    }));
+                default:
+                    return Promise.resolve();
+            }
+        }
+        executionState.status = 'pending';
+        return this.executionContextManager.withContext(executionContext, {
+            name: parameters.name,
+            values: (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? { pageActions: false } : undefined,
+        }, (executionActionContext, abortController) => {
+            const context = this.createActionContext(executionContext, executionActionContext, abortController, parameters);
+            return Promise.resolve()
+                .then(() => {
+                if (isTramvaiAction(action)) {
+                    return action.fn.apply(context, params);
+                }
+                return action(this.context, payload, context.deps);
+            })
+                .then((data) => {
+                executionState.status = 'success';
+                return data;
+            })
+                .catch((err) => {
+                executionState.status = 'failed';
+                throw err;
+            });
+        });
+    }
+    async run(action, ...params) {
+        return this.runInContext(null, action, ...params);
+    }
+    getExecutionState(name) {
+        let executionState = this.execution.get(name);
+        // TODO: probably do not need to create executionState on client as it is not used
+        if (!executionState) {
+            executionState = { status: 'pending', state: {} };
+            this.execution.set(name, executionState);
+        }
+        return executionState;
+    }
+    canExecuteAction(payload, parameters, executionState, type) {
+        const actionChecker = new ActionChecker(this.actionConditionals, payload, parameters, executionState, type);
+        return actionChecker.check();
+    }
+    createActionContext(parentExecutionContext, actionExecutionContext, abortController, parameters) {
+        return {
+            abortController,
+            abortSignal: actionExecutionContext === null || actionExecutionContext === void 0 ? void 0 : actionExecutionContext.abortSignal,
+            executeAction: this.runInContext.bind(this, actionExecutionContext),
+            deps: parameters.deps ? this.di.getOfDeps(parameters.deps) : EMPTY_DEPS,
+            actionType: (parentExecutionContext === null || parentExecutionContext === void 0 ? void 0 : parentExecutionContext.values.pageActions) ? 'page' : 'standalone',
+            dispatch: this.store.dispatch,
+            getState: this.store.getState,
+        };
+    }
+}
+
+export { ActionExecution, getParameters };

package/lib/actions/actionExecution.es.js

@@ -0,0 +1,107 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import identity from '@tinkoff/utils/function/identity';
+import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+import objectMap from '@tinkoff/utils/object/map';
+import { ConditionFailError } from '@tinkoff/errors';
+import { ActionChecker } from './actionChecker.es.js';
+import { actionType } from './constants.es.js';
+import { actionTramvaiReducer } from './actionTramvaiReducer.es.js';
+
+const EMPTY_DEPS = {};
+const DEFAULT_PAYLOAD = {};
+const getParameters = (action) => action[ACTION_PARAMETERS];
+class ActionExecution {
+    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+        this.actionConditionals = flatten(actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
+        this.context = context;
+        this.store = store;
+        this.di = di;
+        this.executionContextManager = executionContextManager;
+        this.execution = new Map();
+        this.transformAction = transformAction || identity;
+        const initialState = store.getState(actionTramvaiReducer);
+        if (initialState && initialState.serverState) {
+            objectMap((value, key) => {
+                this.execution.set(key, value);
+            }, initialState.serverState);
+        }
+    }
+    async runInContext(executionContext, action, ...params) {
+        var _a, _b;
+        let parameters;
+        const payload = (_a = params[0]) !== null && _a !== void 0 ? _a : DEFAULT_PAYLOAD;
+        // TODO: replace type with pure context usage
+        const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? actionType.global : actionType.local;
+        // TODO: remove else branch after migration to new declareAction
+        if (isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        const executionState = this.getExecutionState(parameters.name);
+        if (!this.canExecuteAction(payload, parameters, executionState, type)) {
+            switch (parameters.conditionsFailResult) {
+                case 'reject':
+                    return Promise.reject(new ConditionFailError({
+                        conditionName: (_b = executionState.forbiddenBy) !== null && _b !== void 0 ? _b : 'unknown',
+                        targetName: parameters.name,
+                    }));
+                default:
+                    return Promise.resolve();
+            }
+        }
+        executionState.status = 'pending';
+        return this.executionContextManager.withContext(executionContext, {
+            name: parameters.name,
+            values: (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? { pageActions: false } : undefined,
+        }, (executionActionContext, abortController) => {
+            const context = this.createActionContext(executionContext, executionActionContext, abortController, parameters);
+            return Promise.resolve()
+                .then(() => {
+                if (isTramvaiAction(action)) {
+                    return action.fn.apply(context, params);
+                }
+                return action(this.context, payload, context.deps);
+            })
+                .then((data) => {
+                executionState.status = 'success';
+                return data;
+            })
+                .catch((err) => {
+                executionState.status = 'failed';
+                throw err;
+            });
+        });
+    }
+    async run(action, ...params) {
+        return this.runInContext(null, action, ...params);
+    }
+    getExecutionState(name) {
+        let executionState = this.execution.get(name);
+        // TODO: probably do not need to create executionState on client as it is not used
+        if (!executionState) {
+            executionState = { status: 'pending', state: {} };
+            this.execution.set(name, executionState);
+        }
+        return executionState;
+    }
+    canExecuteAction(payload, parameters, executionState, type) {
+        const actionChecker = new ActionChecker(this.actionConditionals, payload, parameters, executionState, type);
+        return actionChecker.check();
+    }
+    createActionContext(parentExecutionContext, actionExecutionContext, abortController, parameters) {
+        return {
+            abortController,
+            abortSignal: actionExecutionContext === null || actionExecutionContext === void 0 ? void 0 : actionExecutionContext.abortSignal,
+            executeAction: this.runInContext.bind(this, actionExecutionContext),
+            deps: parameters.deps ? this.di.getOfDeps(parameters.deps) : EMPTY_DEPS,
+            actionType: (parentExecutionContext === null || parentExecutionContext === void 0 ? void 0 : parentExecutionContext.values.pageActions) ? 'page' : 'standalone',
+            dispatch: this.store.dispatch,
+            getState: this.store.getState,
+        };
+    }
+}
+
+export { ActionExecution, getParameters };

package/lib/actions/actionExecution.js

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var flatten = require('@tinkoff/utils/array/flatten');
+var identity = require('@tinkoff/utils/function/identity');
+var core = require('@tramvai/core');
+var objectMap = require('@tinkoff/utils/object/map');
+var errors = require('@tinkoff/errors');
+var actionChecker = require('./actionChecker.js');
+var constants = require('./constants.js');
+var actionTramvaiReducer = require('./actionTramvaiReducer.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+var objectMap__default = /*#__PURE__*/_interopDefaultLegacy(objectMap);
+
+const EMPTY_DEPS = {};
+const DEFAULT_PAYLOAD = {};
+const getParameters = (action) => action[core.ACTION_PARAMETERS];
+class ActionExecution {
+    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+        this.actionConditionals = flatten__default["default"](actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
+        this.context = context;
+        this.store = store;
+        this.di = di;
+        this.executionContextManager = executionContextManager;
+        this.execution = new Map();
+        this.transformAction = transformAction || identity__default["default"];
+        const initialState = store.getState(actionTramvaiReducer.actionTramvaiReducer);
+        if (initialState && initialState.serverState) {
+            objectMap__default["default"]((value, key) => {
+                this.execution.set(key, value);
+            }, initialState.serverState);
+        }
+    }
+    async runInContext(executionContext, action, ...params) {
+        var _a, _b;
+        let parameters;
+        const payload = (_a = params[0]) !== null && _a !== void 0 ? _a : DEFAULT_PAYLOAD;
+        // TODO: replace type with pure context usage
+        const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? constants.actionType.global : constants.actionType.local;
+        // TODO: remove else branch after migration to new declareAction
+        if (core.isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        const executionState = this.getExecutionState(parameters.name);
+        if (!this.canExecuteAction(payload, parameters, executionState, type)) {
+            switch (parameters.conditionsFailResult) {
+                case 'reject':
+                    return Promise.reject(new errors.ConditionFailError({
+                        conditionName: (_b = executionState.forbiddenBy) !== null && _b !== void 0 ? _b : 'unknown',
+                        targetName: parameters.name,
+                    }));
+                default:
+                    return Promise.resolve();
+            }
+        }
+        executionState.status = 'pending';
+        return this.executionContextManager.withContext(executionContext, {
+            name: parameters.name,
+            values: (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? { pageActions: false } : undefined,
+        }, (executionActionContext, abortController) => {
+            const context = this.createActionContext(executionContext, executionActionContext, abortController, parameters);
+            return Promise.resolve()
+                .then(() => {
+                if (core.isTramvaiAction(action)) {
+                    return action.fn.apply(context, params);
+                }
+                return action(this.context, payload, context.deps);
+            })
+                .then((data) => {
+                executionState.status = 'success';
+                return data;
+            })
+                .catch((err) => {
+                executionState.status = 'failed';
+                throw err;
+            });
+        });
+    }
+    async run(action, ...params) {
+        return this.runInContext(null, action, ...params);
+    }
+    getExecutionState(name) {
+        let executionState = this.execution.get(name);
+        // TODO: probably do not need to create executionState on client as it is not used
+        if (!executionState) {
+            executionState = { status: 'pending', state: {} };
+            this.execution.set(name, executionState);
+        }
+        return executionState;
+    }
+    canExecuteAction(payload, parameters, executionState, type) {
+        const actionChecker$1 = new actionChecker.ActionChecker(this.actionConditionals, payload, parameters, executionState, type);
+        return actionChecker$1.check();
+    }
+    createActionContext(parentExecutionContext, actionExecutionContext, abortController, parameters) {
+        return {
+            abortController,
+            abortSignal: actionExecutionContext === null || actionExecutionContext === void 0 ? void 0 : actionExecutionContext.abortSignal,
+            executeAction: this.runInContext.bind(this, actionExecutionContext),
+            deps: parameters.deps ? this.di.getOfDeps(parameters.deps) : EMPTY_DEPS,
+            actionType: (parentExecutionContext === null || parentExecutionContext === void 0 ? void 0 : parentExecutionContext.values.pageActions) ? 'page' : 'standalone',
+            dispatch: this.store.dispatch,
+            getState: this.store.getState,
+        };
+    }
+}
+
+exports.ActionExecution = ActionExecution;
+exports.getParameters = getParameters;

package/lib/actions/actionPageRunner.browser.browser.js

@@ -0,0 +1,33 @@
+import { isSilentError } from '@tinkoff/errors';
+import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+
+class ActionPageRunner {
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.logger('action:action-page-runner');
+    }
+    runActions(actions, stopRunAtError = () => false) {
+        return this.deps.executionContextManager.withContext(this.deps.commandLineExecutionContext(), { name: 'pageActions', values: { pageActions: true } }, async (executionContext) => {
+            const actionMapper = (action) => {
+                return Promise.resolve()
+                    .then(() => this.deps.actionExecution.runInContext(executionContext, action))
+                    .catch((error) => {
+                    if (!isSilentError(error)) {
+                        const parameters = isTramvaiAction(action) ? action : action[ACTION_PARAMETERS];
+                        this.log.error({
+                            error,
+                            event: `action-execution-error`,
+                            message: `${parameters.name} execution error`,
+                        });
+                    }
+                    if (stopRunAtError(error)) {
+                        throw error;
+                    }
+                });
+            };
+            await Promise.all(actions.map(actionMapper));
+        });
+    }
+}
+
+export { ActionPageRunner };

package/lib/actions/actionPageRunner.es.js

@@ -0,0 +1,61 @@
+import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+import { isSilentError } from '@tinkoff/errors';
+import { actionServerStateEvent } from './actionTramvaiReducer.es.js';
+
+class ActionPageRunner {
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.logger('action:action-page-runner');
+    }
+    // TODO stopRunAtError нужен только для редиректов на стороне сервера в экшенах. И нужно пересмотреть реализацию редиректов
+    runActions(actions, stopRunAtError = () => false) {
+        return this.deps.executionContextManager.withContext(this.deps.commandLineExecutionContext(), { name: 'pageActions', values: { pageActions: true } }, (executionContext, abortController) => {
+            return new Promise((resolve, reject) => {
+                const timeoutMarker = setTimeout(() => {
+                    this.log.warn(`page actions has exceeded timeout of ${this.deps.limitTime}ms, ignore some results of execution`);
+                    abortController.abort();
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    endChecker();
+                }, this.deps.limitTime);
+                const endChecker = () => {
+                    clearTimeout(timeoutMarker);
+                    const result = {};
+                    // TODO: dehydrate only actions on first level as inner actions are running on client despite their execution on server
+                    this.deps.actionExecution.execution.forEach((value, key) => {
+                        // достаем значения экшенов, которые успешно выполнились, остальные выполнятся на клиенте
+                        if (value.status === 'success') {
+                            result[key] = value;
+                        }
+                    });
+                    this.syncStateActions(result);
+                    resolve();
+                };
+                const actionMapper = (action) => {
+                    return Promise.resolve()
+                        .then(() => this.deps.actionExecution.runInContext(executionContext, action))
+                        .catch((error) => {
+                        if (!isSilentError(error)) {
+                            const parameters = isTramvaiAction(action) ? action : action[ACTION_PARAMETERS];
+                            this.log.error({
+                                error,
+                                event: `action-execution-error`,
+                                message: `${parameters.name} execution error`,
+                            });
+                        }
+                        if (stopRunAtError(error)) {
+                            clearTimeout(timeoutMarker);
+                            reject(error);
+                        }
+                    });
+                };
+                // eslint-disable-next-line promise/catch-or-return
+                Promise.all(actions.map(actionMapper)).then(endChecker);
+            });
+        });
+    }
+    syncStateActions(success) {
+        return this.deps.store.dispatch(actionServerStateEvent(success));
+    }
+}
+
+export { ActionPageRunner };

package/lib/actions/actionPageRunner.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var errors = require('@tinkoff/errors');
+var actionTramvaiReducer = require('./actionTramvaiReducer.js');
+
+class ActionPageRunner {
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.logger('action:action-page-runner');
+    }
+    // TODO stopRunAtError нужен только для редиректов на стороне сервера в экшенах. И нужно пересмотреть реализацию редиректов
+    runActions(actions, stopRunAtError = () => false) {
+        return this.deps.executionContextManager.withContext(this.deps.commandLineExecutionContext(), { name: 'pageActions', values: { pageActions: true } }, (executionContext, abortController) => {
+            return new Promise((resolve, reject) => {
+                const timeoutMarker = setTimeout(() => {
+                    this.log.warn(`page actions has exceeded timeout of ${this.deps.limitTime}ms, ignore some results of execution`);
+                    abortController.abort();
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    endChecker();
+                }, this.deps.limitTime);
+                const endChecker = () => {
+                    clearTimeout(timeoutMarker);
+                    const result = {};
+                    // TODO: dehydrate only actions on first level as inner actions are running on client despite their execution on server
+                    this.deps.actionExecution.execution.forEach((value, key) => {
+                        // достаем значения экшенов, которые успешно выполнились, остальные выполнятся на клиенте
+                        if (value.status === 'success') {
+                            result[key] = value;
+                        }
+                    });
+                    this.syncStateActions(result);
+                    resolve();
+                };
+                const actionMapper = (action) => {
+                    return Promise.resolve()
+                        .then(() => this.deps.actionExecution.runInContext(executionContext, action))
+                        .catch((error) => {
+                        if (!errors.isSilentError(error)) {
+                            const parameters = core.isTramvaiAction(action) ? action : action[core.ACTION_PARAMETERS];
+                            this.log.error({
+                                error,
+                                event: `action-execution-error`,
+                                message: `${parameters.name} execution error`,
+                            });
+                        }
+                        if (stopRunAtError(error)) {
+                            clearTimeout(timeoutMarker);
+                            reject(error);
+                        }
+                    });
+                };
+                // eslint-disable-next-line promise/catch-or-return
+                Promise.all(actions.map(actionMapper)).then(endChecker);
+            });
+        });
+    }
+    syncStateActions(success) {
+        return this.deps.store.dispatch(actionTramvaiReducer.actionServerStateEvent(success));
+    }
+}
+
+exports.ActionPageRunner = ActionPageRunner;

package/lib/actions/actionRegistry.browser.js

@@ -0,0 +1,33 @@
+import uniq from '@tinkoff/utils/array/uniq';
+import difference from '@tinkoff/utils/array/difference';
+import toArray from '@tinkoff/utils/array/toArray';
+import flatten from '@tinkoff/utils/array/flatten';
+
+const GLOBAL_PARAMETER = '@@global';
+class ActionRegistry {
+    constructor({ actionsList }) {
+        this.actions = new Map([[GLOBAL_PARAMETER, flatten(actionsList)]]);
+    }
+    add(type, actions) {
+        const normalized = toArray(actions);
+        this.actions.set(type, uniq(this.actions.has(type) ? [...this.actions.get(type), ...normalized] : normalized));
+    }
+    get(type, addingActions) {
+        return uniq([...(this.actions.get(type) || []), ...(addingActions || [])]);
+    }
+    getGlobal() {
+        return this.actions.get(GLOBAL_PARAMETER);
+    }
+    remove(type, actions) {
+        if (!actions) {
+            this.actions.delete(type);
+            return;
+        }
+        const normalized = toArray(actions);
+        if (this.actions.has(type)) {
+            this.actions.set(type, difference(this.actions.get(type), normalized));
+        }
+    }
+}
+
+export { ActionRegistry, GLOBAL_PARAMETER };

package/lib/actions/actionRegistry.es.js

@@ -0,0 +1,33 @@
+import uniq from '@tinkoff/utils/array/uniq';
+import difference from '@tinkoff/utils/array/difference';
+import toArray from '@tinkoff/utils/array/toArray';
+import flatten from '@tinkoff/utils/array/flatten';
+
+const GLOBAL_PARAMETER = '@@global';
+class ActionRegistry {
+    constructor({ actionsList }) {
+        this.actions = new Map([[GLOBAL_PARAMETER, flatten(actionsList)]]);
+    }
+    add(type, actions) {
+        const normalized = toArray(actions);
+        this.actions.set(type, uniq(this.actions.has(type) ? [...this.actions.get(type), ...normalized] : normalized));
+    }
+    get(type, addingActions) {
+        return uniq([...(this.actions.get(type) || []), ...(addingActions || [])]);
+    }
+    getGlobal() {
+        return this.actions.get(GLOBAL_PARAMETER);
+    }
+    remove(type, actions) {
+        if (!actions) {
+            this.actions.delete(type);
+            return;
+        }
+        const normalized = toArray(actions);
+        if (this.actions.has(type)) {
+            this.actions.set(type, difference(this.actions.get(type), normalized));
+        }
+    }
+}
+
+export { ActionRegistry, GLOBAL_PARAMETER };

package/lib/actions/actionRegistry.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var uniq = require('@tinkoff/utils/array/uniq');
+var difference = require('@tinkoff/utils/array/difference');
+var toArray = require('@tinkoff/utils/array/toArray');
+var flatten = require('@tinkoff/utils/array/flatten');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var uniq__default = /*#__PURE__*/_interopDefaultLegacy(uniq);
+var difference__default = /*#__PURE__*/_interopDefaultLegacy(difference);
+var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+const GLOBAL_PARAMETER = '@@global';
+class ActionRegistry {
+    constructor({ actionsList }) {
+        this.actions = new Map([[GLOBAL_PARAMETER, flatten__default["default"](actionsList)]]);
+    }
+    add(type, actions) {
+        const normalized = toArray__default["default"](actions);
+        this.actions.set(type, uniq__default["default"](this.actions.has(type) ? [...this.actions.get(type), ...normalized] : normalized));
+    }
+    get(type, addingActions) {
+        return uniq__default["default"]([...(this.actions.get(type) || []), ...(addingActions || [])]);
+    }
+    getGlobal() {
+        return this.actions.get(GLOBAL_PARAMETER);
+    }
+    remove(type, actions) {
+        if (!actions) {
+            this.actions.delete(type);
+            return;
+        }
+        const normalized = toArray__default["default"](actions);
+        if (this.actions.has(type)) {
+            this.actions.set(type, difference__default["default"](this.actions.get(type), normalized));
+        }
+    }
+}
+
+exports.ActionRegistry = ActionRegistry;
+exports.GLOBAL_PARAMETER = GLOBAL_PARAMETER;