@tramvai/module-common 2.70.0 → 2.72.0

package/lib/index.js

@@ -2,1353 +2,50 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
-var eachObj = require('@tinkoff/utils/object/each');
-var core = require('@tramvai/core');
-var moduleEnvironment = require('@tramvai/module-environment');
-var moduleCookie = require('@tramvai/module-cookie');
-var moduleLog = require('@tramvai/module-log');
-var hookRunner = require('@tinkoff/hook-runner');
+var CommonModule = require('./CommonModule.js');
+var CommandModule = require('./command/CommandModule.js');
+var actionExecution = require('./actions/actionExecution.js');
+var executionContextManager = require('./executionContext/executionContextManager.js');
+require('./actions/ActionModule.js');
+var createConsumerContext = require('./createConsumerContext/createConsumerContext.js');
+var ChildAppModule = require('./child-app/ChildAppModule.js');
 var tokensCommon = require('@tramvai/tokens-common');
-var isObject = require('@tinkoff/utils/is/object');
-var isArray = require('@tinkoff/utils/is/array');
-var react = require('@tramvai/react');
-var experiments = require('@tramvai/experiments');
-var pathOr = require('@tinkoff/utils/object/pathOr');
-var flatten = require('@tinkoff/utils/array/flatten');
-var state = require('@tramvai/state');
-var tokensServerPrivate = require('@tramvai/tokens-server-private');
-var url = require('@tinkoff/url');
-var isEmpty = require('@tinkoff/utils/is/empty');
-var values = require('@tinkoff/utils/object/values');
-var tokensCorePrivate = require('@tramvai/tokens-core-private');
-var dippy = require('@tinkoff/dippy');
-var errors = require('@tinkoff/errors');
-var pubsub = require('@tinkoff/pubsub');
-var identity = require('@tinkoff/utils/function/identity');
-var objectMap = require('@tinkoff/utils/object/map');
-var uniq = require('@tinkoff/utils/array/uniq');
-var difference = require('@tinkoff/utils/array/difference');
-var toArray = require('@tinkoff/utils/array/toArray');
-var LRU = require('@tinkoff/lru-cache-nano');
-var tokensServer = require('@tramvai/tokens-server');
-var papi = require('@tramvai/papi');
-var nodeAbortController = require('node-abort-controller');
-var jsxRuntime = require('react/jsx-runtime');
-var tokensRender = require('@tramvai/tokens-render');
-var tokensChildApp = require('@tramvai/tokens-child-app');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var eachObj__default = /*#__PURE__*/_interopDefaultLegacy(eachObj);
-var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
-var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
-var pathOr__default = /*#__PURE__*/_interopDefaultLegacy(pathOr);
-var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
-var values__default = /*#__PURE__*/_interopDefaultLegacy(values);
-var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
-var objectMap__default = /*#__PURE__*/_interopDefaultLegacy(objectMap);
-var uniq__default = /*#__PURE__*/_interopDefaultLegacy(uniq);
-var difference__default = /*#__PURE__*/_interopDefaultLegacy(difference);
-var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
-var LRU__default = /*#__PURE__*/_interopDefaultLegacy(LRU);
+var moduleCookie = require('@tramvai/module-cookie');
+var always = require('./actions/conditions/always.js');
+var onlyServer = require('./actions/conditions/onlyServer.js');
+var onlyBrowser = require('./actions/conditions/onlyBrowser.js');
+var pageServer = require('./actions/conditions/pageServer.js');
+var pageBrowser = require('./actions/conditions/pageBrowser.js');
 
-const FS_PAGES_DEFAULT_BUNDLE = '__default';
-class BundleManager {
-    constructor({ bundleList, componentRegistry, actionRegistry, dispatcher, logger }) {
-        this.bundles = bundleList;
-        this.componentRegistry = componentRegistry;
-        this.actionRegistry = actionRegistry;
-        this.dispatcher = dispatcher;
-        if (experiments.fileSystemPagesEnabled()) {
-            const log = logger('file-system-pages:bundle-manager');
-            const components = experiments.getAllFileSystemPages();
-            const layouts = experiments.getAllFileSystemLayouts();
-            const errorBoundaries = experiments.getAllFileSystemErrorBoundaries();
-            const getComponentsFor = (mapping, getKey) => Object.keys(mapping).reduce((result, key) => {
-                // eslint-disable-next-line no-param-reassign
-                result[getKey(key)] = mapping[key];
-                return result;
-            }, {});
-            const componentsDefaultBundle = core.createBundle({
-                name: FS_PAGES_DEFAULT_BUNDLE,
-                components: {
-                    ...getComponentsFor(layouts, experiments.fileSystemPageToLayoutKey),
-                    ...getComponentsFor(errorBoundaries, experiments.fileSystemPageToErrorBoundaryKey),
-                    ...components,
-                },
-            });
-            this.bundles[FS_PAGES_DEFAULT_BUNDLE] = () => Promise.resolve({
-                default: componentsDefaultBundle,
-            });
-            for (const key in componentsDefaultBundle.components) {
-                this.componentRegistry.add(key, componentsDefaultBundle.components[key], FS_PAGES_DEFAULT_BUNDLE);
-            }
-            log.debug({
-                event: 'create default bundle with file-system pages',
-                components: Object.keys(components),
-            });
-        }
-    }
-    get(name, pageComponent) {
-        // use fake bundle with file-system pages
-        if (experiments.isFileSystemPageComponent(pageComponent)) {
-            // eslint-disable-next-line no-param-reassign
-            name = FS_PAGES_DEFAULT_BUNDLE;
-        }
-        return this.loadBundle(name, pageComponent).then((bundle) => this.resolve(bundle.default, pageComponent));
-    }
-    has(name, pageComponent) {
-        // use fake bundle with file-system pages
-        if (experiments.isFileSystemPageComponent(pageComponent)) {
-            // eslint-disable-next-line no-param-reassign
-            name = FS_PAGES_DEFAULT_BUNDLE;
-        }
-        return !!this.bundles[name];
-    }
-    async resolve(bundle, pageComponent) {
-        // preload `lazy` components then register actions and reducers
-        if (pageComponent && bundle.components[pageComponent]) {
-            const componentOrLoader = bundle.components[pageComponent];
-            const component = await react.resolveLazyComponent(componentOrLoader);
-            if (!component) {
-                return;
-            }
-            // allow page components to register any other components
-            if ('components' in component && isObject__default["default"](component.components)) {
-                eachObj__default["default"]((cmp, name) => {
-                    this.componentRegistry.add(name, cmp, pageComponent);
-                }, component.components);
-            }
-            if ('actions' in component && isArray__default["default"](component.actions)) {
-                this.actionRegistry.add(pageComponent, component.actions);
-            }
-            if ('reducers' in component && isArray__default["default"](component.reducers)) {
-                component.reducers.forEach((reducer) => {
-                    this.dispatcher.registerStore(reducer);
-                });
-            }
-        }
-        eachObj__default["default"]((component, name) => {
-            this.componentRegistry.add(name, component, bundle.name);
-        }, bundle.components);
-        if (bundle.actions) {
-            this.actionRegistry.add(bundle.name, bundle.actions);
-        }
-        if (bundle.reducers) {
-            bundle.reducers.forEach((reducer) => {
-                this.dispatcher.registerStore(reducer);
-            });
-        }
-        return bundle;
-    }
-    loadBundle(name, pageComponent) {
-        if (!this.has(name, pageComponent)) {
-            return Promise.reject(new Error(`Bundle "${name}" not found`));
-        }
-        return this.bundles[name]().catch((e) => react.__lazyErrorHandler(e, this.bundles[name]));
-    }
-}
 
-const DEFAULT_GROUP = '__default';
-class ComponentRegistry {
-    constructor({ componentList } = {}) {
-        this.components = {
-            [DEFAULT_GROUP]: Object.assign({}, ...flatten__default["default"](componentList !== null && componentList !== void 0 ? componentList : [])),
-        };
-    }
-    add(name, component, group = DEFAULT_GROUP) {
-        const groupComponents = this.components[group] || {};
-        groupComponents[name] = component;
-        this.components[group] = groupComponents;
-    }
-    get(name, group = DEFAULT_GROUP) {
-        const groupComponents = this.components[group] || {};
-        return groupComponents[name] || this.components[DEFAULT_GROUP][name];
-    }
-    getComponentParam(param, defaultValue, component, group) {
-        return pathOr__default["default"]([param], defaultValue, this.get(component, group));
-    }
-}
 
-const setRequest = state.createEvent('setRequest');
-const RequestManagerStore = state.createReducer('requestManager', {}).on(setRequest, (_, state) => {
-    return state;
+Object.defineProperty(exports, 'CommonModule', {
+	enumerable: true,
+	get: function () { return CommonModule.CommonModule; }
+});
+Object.defineProperty(exports, 'CommandModule', {
+	enumerable: true,
+	get: function () { return CommandModule.CommandModule; }
+});
+exports.ActionExecution = actionExecution.ActionExecution;
+exports.ExecutionContextManager = executionContextManager.ExecutionContextManager;
+exports.createConsumerContext = createConsumerContext.createConsumerContext;
+Object.defineProperty(exports, 'CommonChildAppModule', {
+	enumerable: true,
+	get: function () { return ChildAppModule.CommonChildAppModule; }
 });
-
-class RequestManager {
-    constructor({ request }) {
-        this.request = request || {};
-        if (typeof window === 'undefined') {
-            this.url = url.format({
-                protocol: this.getHeader('x-forwarded-proto') || this.request.protocol,
-                host: this.getHost(),
-                path: this.request.url,
-            });
-        }
-        else {
-            this.url = window.location.href;
-        }
-    }
-    getBody() {
-        return this.request.body;
-    }
-    getUrl() {
-        return this.url;
-    }
-    getParsedUrl() {
-        if (!this.parsedUrl) {
-            this.parsedUrl = url.parse(this.url);
-        }
-        return this.parsedUrl;
-    }
-    getMethod() {
-        return this.request.method;
-    }
-    getHeader(key) {
-        var _a;
-        return (_a = this.request.headers) === null || _a === void 0 ? void 0 : _a[key];
-    }
-    getHeaders() {
-        return this.request.headers;
-    }
-    getCookie(key) {
-        return this.request.cookies[key];
-    }
-    getCookies() {
-        return this.request.cookies;
-    }
-    getClientIp() {
-        var _a, _b;
-        return this.getHeader('x-real-ip') || ((_b = (_a = this.request) === null || _a === void 0 ? void 0 : _a.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress) || '';
-    }
-    getHost() {
-        if (typeof window === 'undefined') {
-            return (this.getHeader('x-original-host') || this.getHeader('host'));
-        }
-        return window.location.host;
-    }
-}
-
-const sharedProviders$1 = [
-    core.provide({
-        provide: tokensCommon.REQUEST_MANAGER_TOKEN,
-        scope: core.Scope.REQUEST,
-        useClass: RequestManager,
-        deps: {
-            request: tokensServerPrivate.FASTIFY_REQUEST,
-        },
-    }),
-    core.provide({
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: RequestManagerStore,
-    }),
-];
-
-let RequestManagerModule = class RequestManagerModule {
-};
-RequestManagerModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            ...sharedProviders$1,
-            core.provide({
-                provide: core.commandLineListTokens.customerStart,
-                multi: true,
-                useFactory: ({ context, requestManager }) => {
-                    return function dehydrateRequestManager() {
-                        return context.dispatch(setRequest({
-                            body: requestManager.getBody(),
-                            headers: {
-                                'x-real-ip': requestManager.getClientIp(),
-                            },
-                        }));
-                    };
-                },
-                deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
-                    requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
-                },
-            }),
-        ],
-    })
-], RequestManagerModule);
-
-class ResponseManager {
-    constructor() {
-        this.body = '';
-        this.headers = {};
-        this.cookies = {};
-        this.status = 200;
-    }
-    getBody() {
-        return this.body;
-    }
-    setBody(value) {
-        this.body = value;
-    }
-    getHeader(key) {
-        if (key === 'set-cookie') {
-            return values__default["default"](this.cookies);
-        }
-        return this.headers[key];
-    }
-    getHeaders() {
-        if (isEmpty__default["default"](this.cookies)) {
-            return this.headers;
-        }
-        return {
-            ...this.headers,
-            'Set-Cookie': values__default["default"](this.cookies),
-        };
-    }
-    setHeader(key, value) {
-        this.headers[key] = value;
-    }
-    getCookie(key) {
-        return this.cookies[key];
-    }
-    getCookies() {
-        return this.cookies;
-    }
-    setCookie(key, value) {
-        this.cookies[key] = value;
-    }
-    setStatus(status) {
-        this.status = status;
-    }
-    getStatus() {
-        return this.status;
-    }
-}
-
-const sharedProviders = [
-    core.provide({
-        provide: tokensCommon.RESPONSE_MANAGER_TOKEN,
-        scope: core.Scope.REQUEST,
-        useClass: ResponseManager,
-    }),
-];
-
-let ResponseManagerModule = class ResponseManagerModule {
-};
-ResponseManagerModule = tslib.__decorate([
-    core.Module({
-        providers: [...sharedProviders],
-    })
-], ResponseManagerModule);
-
-class ConsumerContext {
-    constructor({ di, dispatcherContext, pubsub, store }) {
-        /* Side Effects */
-        this.executeAction = (action, payload) => {
-            return this.di.get(tokensCommon.ACTION_EXECUTION_TOKEN).run(action, payload);
-        };
-        /* State manager */
-        this.dispatch = (actionOrNameEvent, payload) => {
-            return new Promise((resolve, reject) => {
-                try {
-                    resolve(this.store.dispatch(state.convertAction(actionOrNameEvent, payload)));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-        };
-        this.dispatchWith = (createActionOrType, options) => {
-            return typeof createActionOrType === 'function'
-                ? (...args) => this.dispatch(createActionOrType(...args), options)
-                : (payload) => this.dispatch(createActionOrType, payload);
-        };
-        /**
-         * @deprecated
-         */
-        this.getStore = (store) => {
-            return this.dispatcher.getStore(store);
-        };
-        this.dehydrate = () => ({
-            dispatcher: this.dispatcher.dehydrate(),
-        });
-        this.getState = (...args) => {
-            return this.store.getState(args[0]);
-        };
-        this.subscribe = (...args) => {
-            return this.store.subscribe(args[0], args[1]);
-        };
-        this.hasStore = (store) => this.dispatcher.hasStore(store);
-        this.registerStore = (store) => this.dispatcher.registerStore(store);
-        this.unregisterStore = (store) => this.dispatcher.unregisterStore(store);
-        this.store = store;
-        // @ts-expect-error
-        this.dispatcher = dispatcherContext;
-        // TODO убрать, нужно для некоторых старых сторов на платформе
-        this.dispatcher.setContext(this);
-        this.di = di; // кажется этого здесь не  должно быть
-        this.pubsub = pubsub;
-    }
-}
-function createConsumerContext({ di, dispatcherContext, pubsub, store }) {
-    return new ConsumerContext({
-        di,
-        dispatcherContext,
-        pubsub,
-        store,
-    });
-}
-
-const resolveDi = (type, status, diContainer, providers) => {
-    let di = diContainer;
-    if (status === 'customer' && type !== 'client') {
-        di = dippy.createChildContainer(di);
-    }
-    if (providers) {
-        providers.forEach((item) => {
-            return di.register(item);
-        });
-    }
-    return di;
-};
-class CommandLineRunner {
-    constructor({ lines, rootDi, logger, executionContextManager, executionEndHandlers }) {
-        this.executionContextByDi = new WeakMap();
-        this.abortControllerByDi = new WeakMap();
-        this.lines = lines;
-        this.rootDi = rootDi;
-        this.log = logger('command:command-line-runner');
-        this.executionContextManager = executionContextManager;
-        this.executionEndHandlers = executionEndHandlers;
-    }
-    run(type, status, providers, customDi) {
-        const di = customDi !== null && customDi !== void 0 ? customDi : resolveDi(type, status, this.rootDi, providers);
-        const rootExecutionContext = di.get({ token: tokensCommon.ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
-        this.log.debug({
-            event: 'command-run',
-            type,
-            status,
-        });
-        const timingInfo = {};
-        di.register({ provide: tokensCorePrivate.COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
-        return (this.lines[type][status]
-            .reduce((chain, line) => {
-            return chain.then(() => {
-                const lineName = line.toString();
-                timingInfo[lineName] = { start: performance.now() };
-                // eslint-disable-next-line promise/no-nesting
-                return Promise.resolve()
-                    .then(() => {
-                    return this.executionContextManager.withContext(rootExecutionContext, `command-line:${lineName}`, async (executionContext, abortController) => {
-                        this.executionContextByDi.set(di, executionContext);
-                        this.abortControllerByDi.set(di, abortController);
-                        await this.createLineChain(di, line);
-                    });
-                })
-                    .finally(() => {
-                    timingInfo[lineName].end = performance.now();
-                });
-            });
-        }, Promise.resolve())
-            // После завершения цепочки отдаем context выполнения
-            .finally(() => {
-            this.executionContextByDi.delete(di);
-            this.abortControllerByDi.delete(di);
-            if (this.executionEndHandlers) {
-                for (const executionEndHandler of this.executionEndHandlers) {
-                    executionEndHandler(di, type, status, timingInfo);
-                }
-            }
-        })
-            .then(() => di));
-    }
-    resolveExecutionContextFromDi(di) {
-        var _a;
-        return (_a = this.executionContextByDi.get(di)) !== null && _a !== void 0 ? _a : null;
-    }
-    createLineChain(di, line) {
-        let lineInstance;
-        try {
-            lineInstance = di.get({ token: line, optional: true });
-            // Пропускаем step. Так как нет действий
-            if (lineInstance === null) {
-                return Promise.resolve();
-            }
-        }
-        catch (e) {
-            // Логируем ошибку и дальше падаем
-            this.log.error(e);
-            return this.throwError(e, di);
-        }
-        if (!Array.isArray(lineInstance)) {
-            return this.instanceExecute(lineInstance, line, di);
-        }
-        return Promise.all(lineInstance.map((instance) => {
-            return this.instanceExecute(instance, line, di);
-        }));
-    }
-    instanceExecute(instance, line, di) {
-        if (!(instance instanceof Function)) {
-            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${line.toString()}", received "${instance}".
-      Check that all commandLineListTokens subscribers return functions`);
-            if (process.env.NODE_ENV !== 'production') {
-                const instances = di.get(line);
-                const record = di.getRecord(line.toString());
-                // пробегаемся по всем инстансам и для текущего получаем его запись, из которой можно получить стек
-                for (let i = 0; i < instances.length; i++) {
-                    if (instances[i] === instance) {
-                        // @ts-expect-error
-                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
-                    }
-                }
-            }
-            this.log.error({
-                event: 'line-error',
-                error,
-                line: line.toString(),
-            });
-            return;
-        }
-        const { name = '' } = instance;
-        this.log.debug({
-            event: 'line-run',
-            line: line.toString(),
-            command: name,
-        });
-        return Promise.resolve()
-            .then(() => instance())
-            .catch((err) => {
-            var _a;
-            this.log[errors.isSilentError(err) ? 'debug' : 'error']({
-                event: 'line-error',
-                error: err,
-                line: line.toString(),
-                command: name,
-            });
-            // in case if any error happens during line execution results from other line handlers will not be used anyway
-            (_a = this.abortControllerByDi.get(di)) === null || _a === void 0 ? void 0 : _a.abort();
-            this.throwError(err, di);
-        });
-    }
-    // eslint-disable-next-line class-methods-use-this
-    throwError(err, di) {
-        if (typeof err === 'object') {
-            // eslint-disable-next-line no-param-reassign
-            err.di = di;
-        }
-        throw err;
-    }
-}
-
-const command$1 = {
-    init: [core.commandLineListTokens.init, core.commandLineListTokens.listen],
-    close: [core.commandLineListTokens.close],
-    customer: [
-        core.commandLineListTokens.customerStart,
-        core.commandLineListTokens.resolveUserDeps,
-        core.commandLineListTokens.resolvePageDeps,
-        core.commandLineListTokens.generatePage,
-        core.commandLineListTokens.clear,
-    ],
-    spa: [
-        core.commandLineListTokens.resolveUserDeps,
-        core.commandLineListTokens.resolvePageDeps,
-        core.commandLineListTokens.spaTransition,
-    ],
-    afterSpa: [core.commandLineListTokens.afterSpaTransition],
-};
-const lines$1 = {
-    server: command$1,
-    client: command$1,
-};
-
-exports.CommandModule = class CommandModule {
-};
-exports.CommandModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            dippy.provide({
-                // Раннер процессов
-                provide: core.COMMAND_LINE_RUNNER_TOKEN,
-                scope: dippy.Scope.SINGLETON,
-                useClass: CommandLineRunner,
-                deps: {
-                    lines: core.COMMAND_LINES_TOKEN,
-                    rootDi: core.DI_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    executionEndHandlers: {
-                        token: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
-                        optional: true,
-                    },
-                },
-            }),
-            dippy.provide({
-                provide: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                useFactory: ({ di, commandLineRunner }) => {
-                    return () => {
-                        return commandLineRunner.resolveExecutionContextFromDi(di);
-                    };
-                },
-                deps: {
-                    di: core.DI_TOKEN,
-                    commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
-                },
-            }),
-            dippy.provide({
-                // Дефолтный список команл
-                provide: core.COMMAND_LINES_TOKEN,
-                scope: dippy.Scope.SINGLETON,
-                useValue: lines$1,
-            }),
-        ],
-    })
-], exports.CommandModule);
-
-let PubSubModule = class PubSubModule {
-};
-PubSubModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                // Фабрика для создания pubsub
-                provide: tokensCommon.PUBSUB_FACTORY_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: (deps) => () => {
-                    return new pubsub.PubSub({
-                        logger: deps.logger('pubsub'),
-                    });
-                },
-                deps: {
-                    logger: tokensCommon.LOGGER_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.PUBSUB_TOKEN,
-                scope: core.Scope.REQUEST,
-                useFactory: ({ createPubsub }) => createPubsub(),
-                deps: {
-                    createPubsub: tokensCommon.PUBSUB_FACTORY_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.ROOT_PUBSUB_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ createPubsub }) => createPubsub(),
-                deps: {
-                    createPubsub: tokensCommon.PUBSUB_FACTORY_TOKEN,
-                },
-            }),
-        ],
-    })
-], PubSubModule);
-
-const providers$2 = [];
-
-const actionServerStateEvent = state.createEvent('action state execution in server');
-const initalState = { serverState: {} };
-const actionTramvaiReducer = state.createReducer('actionTramvai', initalState).on(actionServerStateEvent, (state, payload) => ({
-    ...state,
-    serverState: payload,
-}));
-
-/**
- * @deprecated only for compatibility with legacy createAction
- */
-const actionType = {
-    global: 'global',
-    local: 'local',
-};
-
-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 === 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;
-    }
-}
-
-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);
-        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 ? actionType.global : 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 = 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,
-        };
-    }
-}
-
-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));
-        }
-    }
-}
-
-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(actionServerStateEvent(success));
-    }
-}
-
-const alwaysCondition = {
-    key: 'alwaysCondition',
-    fn: (checker) => {
-        if (checker.conditions.always) {
-            checker.allow();
-        }
-    },
-};
-
-const isServer = typeof window === 'undefined';
-const isBrowser = !isServer;
-
-const onlyServer = {
-    key: 'onlyServer',
-    fn: (checker) => {
-        if (checker.conditions.onlyServer && isBrowser) {
-            checker.forbid();
-        }
-    },
-};
-
-const onlyBrowser = {
-    key: 'onlyBrowser',
-    fn: (checker) => {
-        if (checker.conditions.onlyBrowser && isServer) {
-            checker.forbid();
-        }
-    },
-};
-
-const pageServer = {
-    key: 'pageServer',
-    fn: (checker) => {
-        if (checker.conditions.pageServer && checker.type === actionType.global && isBrowser) {
-            checker.forbid();
-        }
-    },
-};
-
-const pageBrowser = {
-    key: 'pageBrowser',
-    fn: (checker) => {
-        if (checker.conditions.pageBrowser && checker.type === actionType.global && isServer) {
-            checker.forbid();
-        }
-    },
-};
-
-const LIMIT_ACTION_GLOBAL_TIME_RUN = core.createToken('limitActionGlobalTimeRun');
-let ActionModule = class ActionModule {
-};
-ActionModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensCommon.COMBINE_REDUCERS,
-                multi: true,
-                useValue: actionTramvaiReducer,
-            }),
-            core.provide({
-                // Регистер глобальных экшенов
-                provide: tokensCommon.ACTION_REGISTRY_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useClass: ActionRegistry,
-                deps: { actionsList: core.ACTIONS_LIST_TOKEN },
-            }),
-            core.provide({
-                provide: tokensCommon.ACTION_EXECUTION_TOKEN,
-                scope: core.Scope.REQUEST,
-                useClass: ActionExecution,
-                deps: {
-                    actionConditionals: { token: tokensCommon.ACTION_CONDITIONALS, optional: true },
-                    context: tokensCommon.CONTEXT_TOKEN,
-                    store: tokensCommon.STORE_TOKEN,
-                    di: core.DI_TOKEN,
-                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    transformAction: {
-                        token: 'actionTransformAction',
-                        optional: true,
-                    },
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.ACTION_PAGE_RUNNER_TOKEN,
-                scope: core.Scope.REQUEST,
-                useClass: ActionPageRunner,
-                deps: {
-                    actionExecution: tokensCommon.ACTION_EXECUTION_TOKEN,
-                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    commandLineExecutionContext: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                    store: tokensCommon.STORE_TOKEN,
-                    limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: LIMIT_ACTION_GLOBAL_TIME_RUN,
-                useValue: 500,
-            }),
-            core.provide({
-                provide: tokensCommon.ACTION_CONDITIONALS,
-                multi: true,
-                useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
-            }),
-        ],
-    })
-], ActionModule);
-
-let StateModule = class StateModule {
-};
-StateModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensCommon.DISPATCHER_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ stores }) => state.createDispatcher({ stores: stores && flatten__default["default"](stores) }),
-                deps: {
-                    stores: {
-                        token: tokensCommon.COMBINE_REDUCERS,
-                        optional: true,
-                    },
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.DISPATCHER_CONTEXT_TOKEN,
-                scope: core.Scope.REQUEST,
-                useFactory: ({ dispatcher, initialState, middlewares }) => {
-                    return dispatcher.createContext({}, initialState, [
-                        state.devTools.middleware(),
-                        ...flatten__default["default"](middlewares || []),
-                    ]);
-                },
-                deps: {
-                    dispatcher: tokensCommon.DISPATCHER_TOKEN,
-                    middlewares: { token: tokensCommon.STORE_MIDDLEWARE, optional: true },
-                    initialState: { token: tokensCommon.INITIAL_APP_STATE_TOKEN, optional: true },
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.STORE_TOKEN,
-                scope: core.Scope.REQUEST,
-                useFactory: ({ dispatcherContext }) => ({
-                    getState: dispatcherContext.getState.bind(dispatcherContext),
-                    dispatch: dispatcherContext.dispatch.bind(dispatcherContext),
-                    subscribe: dispatcherContext.subscribe.bind(dispatcherContext),
-                }),
-                deps: {
-                    dispatcherContext: tokensCommon.DISPATCHER_CONTEXT_TOKEN,
-                },
-            }),
-        ],
-    })
-], StateModule);
-
-const cacheFactory = (type, options = { max: 100 }) => {
-    return new LRU__default["default"](options);
-};
-
-const papiClearCache = ({ clearCache, logger, }) => {
-    const log = logger('cache:papi-clear-cache');
-    return papi.createPapiMethod({
-        method: 'post',
-        path: '/clear-cache',
-        async handler({ responseManager }) {
-            await clearCache();
-            // DEVOPS-1661
-            responseManager.setStatus(404);
-            responseManager.setHeader('X-Status', 'done');
-            log.info('SERVER:CLEAR:CACHE:INTERNAL');
-        },
-    });
-};
-
-const providers$1 = [
-    core.provide({
-        provide: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
-        multi: true,
-        useFactory: papiClearCache,
-        deps: {
-            clearCache: tokensCommon.CLEAR_CACHE_TOKEN,
-            logger: tokensCommon.LOGGER_TOKEN,
-        },
-    }),
-];
-
-const cachesToken = dippy.createToken('_cachesList');
-let CacheModule = class CacheModule {
-};
-CacheModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            ...providers$1,
-            {
-                provide: cachesToken,
-                scope: core.Scope.SINGLETON,
-                useValue: [],
-            },
-            {
-                provide: tokensCommon.CREATE_CACHE_TOKEN,
-                useFactory: ({ caches, isChildDi }) => {
-                    if (isChildDi) {
-                        return cacheFactory;
-                    }
-                    return (type, ...args) => {
-                        const cache = cacheFactory(type, ...args);
-                        caches.push(cache);
-                        return cache;
-                    };
-                },
-                deps: {
-                    caches: cachesToken,
-                    isChildDi: { token: core.IS_DI_CHILD_CONTAINER_TOKEN, optional: true },
-                },
-            },
-            {
-                provide: tokensCommon.CLEAR_CACHE_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ caches, cachesClear }) => {
-                    return (type) => {
-                        caches.forEach((cache) => cache.clear());
-                        if (cachesClear) {
-                            return Promise.all(cachesClear.map((clear) => clear(type)));
-                        }
-                        return Promise.resolve();
-                    };
-                },
-                deps: {
-                    caches: cachesToken,
-                    cachesClear: { token: tokensCommon.REGISTER_CLEAR_CACHE_TOKEN, optional: true },
-                },
-            },
-        ],
-    })
-], CacheModule);
-
-const EMPTY_VALUES = {};
-const normalizeOptions = (nameOrOptions) => {
-    return typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
-};
-class ExecutionContextManager {
-    async withContext(parentContext, nameOrOptions, cb) {
-        const options = normalizeOptions(nameOrOptions);
-        const { name, values: selfValues = EMPTY_VALUES } = options;
-        const contextName = parentContext ? `${parentContext.name}.${name}` : name;
-        if (parentContext === null || parentContext === void 0 ? void 0 : parentContext.abortSignal.aborted) {
-            throw new errors.ExecutionAbortError({
-                message: `Execution aborted in context "${contextName}"`,
-                contextName,
-            });
-        }
-        const abortController = new nodeAbortController.AbortController();
-        let abortListener;
-        let values = selfValues;
-        if (parentContext) {
-            values = {
-                ...parentContext.values,
-                ...selfValues,
-            };
-            abortListener = () => {
-                abortController.abort();
-            };
-            // abort child context AbortController if parent AbortController was aborted
-            parentContext.abortSignal.addEventListener('abort', abortListener);
-        }
-        const context = {
-            name: contextName,
-            abortSignal: abortController.signal,
-            values,
-        };
-        try {
-            const result = await cb(context, abortController);
-            return result;
-        }
-        catch (error) {
-            if (typeof error === 'object' && !error.executionContextName) {
-                error.executionContextName = context.name;
-            }
-            throw error;
-        }
-        finally {
-            // @ts-expect-error
-            if (abortListener && parentContext) {
-                parentContext.abortSignal.removeEventListener('abort', abortListener);
-            }
-        }
-    }
-}
-
-exports.CommonModule = class CommonModule {
-};
-exports.CommonModule = tslib.__decorate([
-    core.Module({
-        imports: [
-            exports.CommandModule,
-            moduleEnvironment.EnvironmentModule,
-            PubSubModule,
-            moduleLog.LogModule,
-            moduleCookie.CookieModule,
-            ActionModule,
-            StateModule,
-            RequestManagerModule,
-            ResponseManagerModule,
-            CacheModule,
-        ],
-        providers: [
-            core.provide({
-                // Инстанс хук системы
-                provide: tokensCommon.HOOK_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useClass: hookRunner.Hooks,
-            }),
-            core.provide({
-                // Регистр ui компонентов
-                provide: tokensCommon.COMPONENT_REGISTRY_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useClass: ComponentRegistry,
-                deps: {
-                    componentList: { token: 'componentDefaultList', optional: true },
-                },
-            }),
-            core.provide({
-                // Управление бандлами, хранение и получение
-                provide: tokensCommon.BUNDLE_MANAGER_TOKEN,
-                scope: core.Scope.SINGLETON,
-                useFactory: ({ additionalBundleList, ...bundleManagerDeps }) => {
-                    additionalBundleList === null || additionalBundleList === void 0 ? void 0 : additionalBundleList.forEach((bundles) => {
-                        eachObj__default["default"]((bundle, name) => {
-                            const bundleAlreadyExists = name in bundleManagerDeps.bundleList;
-                            if (!bundleAlreadyExists) {
-                                // eslint-disable-next-line no-param-reassign
-                                bundleManagerDeps.bundleList[name] = () => Promise.resolve({ default: bundle });
-                            }
-                        }, bundles);
-                    });
-                    return new BundleManager(bundleManagerDeps);
-                },
-                deps: {
-                    bundleList: core.BUNDLE_LIST_TOKEN,
-                    additionalBundleList: { token: tokensCommon.ADDITIONAL_BUNDLE_TOKEN, optional: true },
-                    componentRegistry: tokensCommon.COMPONENT_REGISTRY_TOKEN,
-                    actionRegistry: tokensCommon.ACTION_REGISTRY_TOKEN,
-                    dispatcher: tokensCommon.DISPATCHER_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                },
-            }),
-            core.provide({
-                //  Клиентский контекст исполнения
-                provide: tokensCommon.CONTEXT_TOKEN,
-                scope: core.Scope.REQUEST,
-                useFactory: createConsumerContext,
-                deps: {
-                    di: core.DI_TOKEN,
-                    pubsub: tokensCommon.PUBSUB_TOKEN,
-                    dispatcherContext: tokensCommon.DISPATCHER_CONTEXT_TOKEN,
-                    store: tokensCommon.STORE_TOKEN,
-                },
-            }),
-            core.provide({
-                provide: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
-                useClass: ExecutionContextManager,
-            }),
-            ...providers$2,
-        ],
-    })
-], exports.CommonModule);
-
-const providers = [];
-
-const stateProviders = [
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: [tokensCommon.DISPATCHER_TOKEN, tokensCommon.STORE_TOKEN, tokensCommon.CONTEXT_TOKEN],
-    }),
-];
-
-const command = {
-    customer: [
-        tokensChildApp.commandLineListTokens.customerStart,
-        tokensChildApp.commandLineListTokens.resolveUserDeps,
-        tokensChildApp.commandLineListTokens.resolvePageDeps,
-    ],
-    clear: [tokensChildApp.commandLineListTokens.clear],
-    spa: [
-        tokensChildApp.commandLineListTokens.resolveUserDeps,
-        tokensChildApp.commandLineListTokens.resolvePageDeps,
-        tokensChildApp.commandLineListTokens.spaTransition,
-    ],
-    afterSpa: [tokensChildApp.commandLineListTokens.afterSpaTransition],
-};
-const lines = {
-    server: command,
-    client: command,
-};
-const commandProviders = [
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: core.COMMAND_LINE_RUNNER_TOKEN,
-    }),
-    core.provide({
-        provide: core.COMMAND_LINES_TOKEN,
-        scope: core.Scope.SINGLETON,
-        useValue: lines,
-    }),
-];
-
-const actionsProviders = [
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: [tokensCommon.ACTION_EXECUTION_TOKEN, tokensCommon.ACTION_PAGE_RUNNER_TOKEN],
-    }),
-    core.provide({
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: actionTramvaiReducer,
-    }),
-];
-
-exports.CommonChildAppModule = class CommonChildAppModule {
-};
-exports.CommonChildAppModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            ...providers,
-            ...stateProviders,
-            ...commandProviders,
-            ...actionsProviders,
-            core.provide({
-                provide: tokensRender.EXTEND_RENDER,
-                multi: true,
-                useFactory: ({ context }) => {
-                    const serverState = typeof window !== 'undefined' ? context.getState() : undefined;
-                    return (render) => {
-                        return (jsxRuntime.jsx(state.Provider, { context: context, serverState: serverState, children: render }));
-                    };
-                },
-                deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
-                },
-            }),
-        ],
-    })
-], exports.CommonChildAppModule);
-
 Object.defineProperty(exports, 'COOKIE_MANAGER_TOKEN', {
-    enumerable: true,
-    get: function () { return moduleCookie.COOKIE_MANAGER_TOKEN; }
+	enumerable: true,
+	get: function () { return moduleCookie.COOKIE_MANAGER_TOKEN; }
 });
-exports.ActionExecution = ActionExecution;
-exports.ExecutionContextManager = ExecutionContextManager;
-exports.alwaysCondition = alwaysCondition;
-exports.createConsumerContext = createConsumerContext;
-exports.onlyBrowser = onlyBrowser;
-exports.onlyServer = onlyServer;
-exports.pageBrowser = pageBrowser;
-exports.pageServer = pageServer;
+exports.alwaysCondition = always.alwaysCondition;
+exports.onlyServer = onlyServer.onlyServer;
+exports.onlyBrowser = onlyBrowser.onlyBrowser;
+exports.pageServer = pageServer.pageServer;
+exports.pageBrowser = pageBrowser.pageBrowser;
 Object.keys(tokensCommon).forEach(function (k) {
-    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-        enumerable: true,
-        get: function () { return tokensCommon[k]; }
-    });
+	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return tokensCommon[k]; }
+	});
 });