@tramvai/module-common 2.70.0 → 2.72.0

package/lib/index.browser.js

@@ -1,1301 +1,14 @@
-import { __decorate } from 'tslib';
-import eachObj from '@tinkoff/utils/object/each';
-import { createBundle, provide, Scope, Module, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN, isTramvaiAction, ACTION_PARAMETERS, createToken, ACTIONS_LIST_TOKEN, IS_DI_CHILD_CONTAINER_TOKEN, BUNDLE_LIST_TOKEN } from '@tramvai/core';
-import { EnvironmentModule } from '@tramvai/module-environment';
-import { CookieModule } from '@tramvai/module-cookie';
-export { COOKIE_MANAGER_TOKEN } from '@tramvai/module-cookie';
-import { LogModule } from '@tramvai/module-log';
-import { Hooks } from '@tinkoff/hook-runner';
-import { REQUEST_MANAGER_TOKEN, COMBINE_REDUCERS, STORE_TOKEN, RESPONSE_MANAGER_TOKEN, ACTION_EXECUTION_TOKEN, ROOT_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, PUBSUB_FACTORY_TOKEN, PUBSUB_TOKEN, ROOT_PUBSUB_TOKEN, INITIAL_APP_STATE_TOKEN, ACTION_REGISTRY_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, ACTION_PAGE_RUNNER_TOKEN, DISPATCHER_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_MIDDLEWARE, CREATE_CACHE_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN, HOOK_TOKEN, COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN } from '@tramvai/tokens-common';
+export { CommonModule } from './CommonModule.browser.js';
+export { CommandModule } from './command/CommandModule.browser.js';
+export { ActionExecution } from './actions/actionExecution.browser.js';
+export { ExecutionContextManager } from './executionContext/executionContextManager.browser.js';
+import './actions/ActionModule.browser.js';
+export { createConsumerContext } from './createConsumerContext/createConsumerContext.browser.js';
+export { CommonChildAppModule } from './child-app/ChildAppModule.browser.js';
 export * from '@tramvai/tokens-common';
-import isObject from '@tinkoff/utils/is/object';
-import isArray from '@tinkoff/utils/is/array';
-import { resolveLazyComponent, __lazyErrorHandler } from '@tramvai/react';
-import { fileSystemPagesEnabled, getAllFileSystemPages, getAllFileSystemLayouts, getAllFileSystemErrorBoundaries, isFileSystemPageComponent, fileSystemPageToLayoutKey, fileSystemPageToErrorBoundaryKey } from '@tramvai/experiments';
-import pathOr from '@tinkoff/utils/object/pathOr';
-import flatten from '@tinkoff/utils/array/flatten';
-import { FASTIFY_REQUEST, FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
-import { createEvent, createReducer, convertAction, createDispatcher, devTools, Provider } from '@tramvai/state';
-import { format, parse } from '@tinkoff/url';
-import isEmpty from '@tinkoff/utils/is/empty';
-import values from '@tinkoff/utils/object/values';
-import { COMMAND_LINE_TIMING_INFO_TOKEN, COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
-import { createChildContainer, provide as provide$1, Scope as Scope$1, createToken as createToken$1 } from '@tinkoff/dippy';
-import { isSilentError, ConditionFailError, ExecutionAbortError } from '@tinkoff/errors';
-import { PubSub } from '@tinkoff/pubsub';
-import identity from '@tinkoff/utils/function/identity';
-import objectMap from '@tinkoff/utils/object/map';
-import uniq from '@tinkoff/utils/array/uniq';
-import difference from '@tinkoff/utils/array/difference';
-import toArray from '@tinkoff/utils/array/toArray';
-import LRU from '@tinkoff/lru-cache-nano';
-import { AbortController } from 'node-abort-controller';
-import { jsx } from 'react/jsx-runtime';
-import { EXTEND_RENDER } from '@tramvai/tokens-render';
-import { CHILD_APP_COMMON_INITIAL_STATE_TOKEN, CHILD_APP_INTERNAL_CONFIG_TOKEN, CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN, commandLineListTokens as commandLineListTokens$1 } from '@tramvai/tokens-child-app';
-
-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 (fileSystemPagesEnabled()) {
-            const log = logger('file-system-pages:bundle-manager');
-            const components = getAllFileSystemPages();
-            const layouts = getAllFileSystemLayouts();
-            const errorBoundaries = 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 = createBundle({
-                name: FS_PAGES_DEFAULT_BUNDLE,
-                components: {
-                    ...getComponentsFor(layouts, fileSystemPageToLayoutKey),
-                    ...getComponentsFor(errorBoundaries, 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 (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 (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 resolveLazyComponent(componentOrLoader);
-            if (!component) {
-                return;
-            }
-            // allow page components to register any other components
-            if ('components' in component && isObject(component.components)) {
-                eachObj((cmp, name) => {
-                    this.componentRegistry.add(name, cmp, pageComponent);
-                }, component.components);
-            }
-            if ('actions' in component && isArray(component.actions)) {
-                this.actionRegistry.add(pageComponent, component.actions);
-            }
-            if ('reducers' in component && isArray(component.reducers)) {
-                component.reducers.forEach((reducer) => {
-                    this.dispatcher.registerStore(reducer);
-                });
-            }
-        }
-        eachObj((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) => __lazyErrorHandler(e, this.bundles[name]));
-    }
-}
-
-const DEFAULT_GROUP = '__default';
-class ComponentRegistry {
-    constructor({ componentList } = {}) {
-        this.components = {
-            [DEFAULT_GROUP]: Object.assign({}, ...flatten(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([param], defaultValue, this.get(component, group));
-    }
-}
-
-const setRequest = createEvent('setRequest');
-const RequestManagerStore = createReducer('requestManager', {}).on(setRequest, (_, state) => {
-    return state;
-});
-
-class RequestManager {
-    constructor({ request }) {
-        this.request = request || {};
-        if (typeof window === 'undefined') {
-            this.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 = 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 = [
-    provide({
-        provide: REQUEST_MANAGER_TOKEN,
-        scope: Scope.REQUEST,
-        useClass: RequestManager,
-        deps: {
-            request: FASTIFY_REQUEST,
-        },
-    }),
-    provide({
-        provide: COMBINE_REDUCERS,
-        multi: true,
-        useValue: RequestManagerStore,
-    }),
-];
-
-let RequestManagerModule = class RequestManagerModule {
-};
-RequestManagerModule = __decorate([
-    Module({
-        providers: [
-            ...sharedProviders$1,
-            provide({
-                provide: FASTIFY_REQUEST,
-                useFactory: ({ store }) => {
-                    const fromServer = store.getState(RequestManagerStore);
-                    return {
-                        ...fromServer,
-                        headers: {
-                            ...fromServer === null || fromServer === void 0 ? void 0 : fromServer.headers,
-                            'user-agent': navigator.userAgent,
-                            cookie: document.cookie,
-                        },
-                        // the type is not actually the same and is only partially compatible with actual request object
-                        // but provide it as a backup for some of the isomorphic code
-                        // anyway it is better not to use request/response on client
-                    };
-                },
-                deps: {
-                    store: STORE_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(this.cookies);
-        }
-        return this.headers[key];
-    }
-    getHeaders() {
-        if (isEmpty(this.cookies)) {
-            return this.headers;
-        }
-        return {
-            ...this.headers,
-            'Set-Cookie': values(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 = [
-    provide({
-        provide: RESPONSE_MANAGER_TOKEN,
-        scope: Scope.REQUEST,
-        useClass: ResponseManager,
-    }),
-];
-
-let ResponseManagerModule = class ResponseManagerModule {
-};
-ResponseManagerModule = __decorate([
-    Module({
-        providers: [
-            ...sharedProviders,
-            provide({
-                provide: FASTIFY_RESPONSE,
-                // @ts-expect-error
-                useValue: {},
-            }),
-        ],
-    })
-], ResponseManagerModule);
-
-class ConsumerContext {
-    constructor({ di, dispatcherContext, pubsub, store }) {
-        /* Side Effects */
-        this.executeAction = (action, payload) => {
-            return this.di.get(ACTION_EXECUTION_TOKEN).run(action, payload);
-        };
-        /* State manager */
-        this.dispatch = (actionOrNameEvent, payload) => {
-            return new Promise((resolve, reject) => {
-                try {
-                    resolve(this.store.dispatch(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 = 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: ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
-        this.log.debug({
-            event: 'command-run',
-            type,
-            status,
-        });
-        const timingInfo = {};
-        di.register({ provide: 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[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: [commandLineListTokens.init, commandLineListTokens.listen],
-    close: [commandLineListTokens.close],
-    customer: [
-        commandLineListTokens.customerStart,
-        commandLineListTokens.resolveUserDeps,
-        commandLineListTokens.resolvePageDeps,
-        commandLineListTokens.generatePage,
-        commandLineListTokens.clear,
-    ],
-    spa: [
-        commandLineListTokens.resolveUserDeps,
-        commandLineListTokens.resolvePageDeps,
-        commandLineListTokens.spaTransition,
-    ],
-    afterSpa: [commandLineListTokens.afterSpaTransition],
-};
-const lines$1 = {
-    server: command$1,
-    client: command$1,
-};
-
-let CommandModule = class CommandModule {
-};
-CommandModule = __decorate([
-    Module({
-        providers: [
-            provide$1({
-                // Раннер процессов
-                provide: COMMAND_LINE_RUNNER_TOKEN,
-                scope: Scope$1.SINGLETON,
-                useClass: CommandLineRunner,
-                deps: {
-                    lines: COMMAND_LINES_TOKEN,
-                    rootDi: DI_TOKEN,
-                    logger: LOGGER_TOKEN,
-                    executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    executionEndHandlers: {
-                        token: COMMAND_LINE_EXECUTION_END_TOKEN,
-                        optional: true,
-                    },
-                },
-            }),
-            provide$1({
-                provide: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                useFactory: ({ di, commandLineRunner }) => {
-                    return () => {
-                        return commandLineRunner.resolveExecutionContextFromDi(di);
-                    };
-                },
-                deps: {
-                    di: DI_TOKEN,
-                    commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
-                },
-            }),
-            provide$1({
-                // Дефолтный список команл
-                provide: COMMAND_LINES_TOKEN,
-                scope: Scope$1.SINGLETON,
-                useValue: lines$1,
-            }),
-        ],
-    })
-], CommandModule);
-
-let PubSubModule = class PubSubModule {
-};
-PubSubModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                // Фабрика для создания pubsub
-                provide: PUBSUB_FACTORY_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: (deps) => () => {
-                    return new PubSub({
-                        logger: deps.logger('pubsub'),
-                    });
-                },
-                deps: {
-                    logger: LOGGER_TOKEN,
-                },
-            }),
-            provide({
-                provide: PUBSUB_TOKEN,
-                scope: Scope.REQUEST,
-                useFactory: ({ createPubsub }) => createPubsub(),
-                deps: {
-                    createPubsub: PUBSUB_FACTORY_TOKEN,
-                },
-            }),
-            provide({
-                provide: ROOT_PUBSUB_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ createPubsub }) => createPubsub(),
-                deps: {
-                    createPubsub: PUBSUB_FACTORY_TOKEN,
-                },
-            }),
-        ],
-    })
-], PubSubModule);
-
-const providers$2 = [
-    provide({
-        provide: INITIAL_APP_STATE_TOKEN,
-        useFactory: () => { var _a, _b; return JSON.parse((_b = (_a = document.getElementById('__TRAMVAI_STATE__')) === null || _a === void 0 ? void 0 : _a.textContent) !== null && _b !== void 0 ? _b : '{}'); },
-        scope: Scope.REQUEST,
-    }),
-    provide({
-        provide: commandLineListTokens.listen,
-        useFactory: ({ commandLineRunner, }) => {
-            return function initClientCommand() {
-                return commandLineRunner.run('client', 'customer');
-            };
-        },
-        deps: { commandLineRunner: COMMAND_LINE_RUNNER_TOKEN },
-        multi: true,
-    }),
-];
-
-const actionServerStateEvent = createEvent('action state execution in server');
-const initalState = { serverState: {} };
-const actionTramvaiReducer = 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[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,
-        };
-    }
-}
-
-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));
-        }
-    }
-}
-
-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));
-        });
-    }
-}
-
-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 = createToken('limitActionGlobalTimeRun');
-let ActionModule = class ActionModule {
-};
-ActionModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                provide: COMBINE_REDUCERS,
-                multi: true,
-                useValue: actionTramvaiReducer,
-            }),
-            provide({
-                // Регистер глобальных экшенов
-                provide: ACTION_REGISTRY_TOKEN,
-                scope: Scope.SINGLETON,
-                useClass: ActionRegistry,
-                deps: { actionsList: ACTIONS_LIST_TOKEN },
-            }),
-            provide({
-                provide: ACTION_EXECUTION_TOKEN,
-                scope: Scope.REQUEST,
-                useClass: ActionExecution,
-                deps: {
-                    actionConditionals: { token: ACTION_CONDITIONALS, optional: true },
-                    context: CONTEXT_TOKEN,
-                    store: STORE_TOKEN,
-                    di: DI_TOKEN,
-                    executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    transformAction: {
-                        token: 'actionTransformAction',
-                        optional: true,
-                    },
-                },
-            }),
-            provide({
-                provide: ACTION_PAGE_RUNNER_TOKEN,
-                scope: Scope.REQUEST,
-                useClass: ActionPageRunner,
-                deps: {
-                    actionExecution: ACTION_EXECUTION_TOKEN,
-                    executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
-                    commandLineExecutionContext: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                    store: STORE_TOKEN,
-                    limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
-                    logger: LOGGER_TOKEN,
-                },
-            }),
-            provide({
-                provide: LIMIT_ACTION_GLOBAL_TIME_RUN,
-                useValue: 500,
-            }),
-            provide({
-                provide: ACTION_CONDITIONALS,
-                multi: true,
-                useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
-            }),
-        ],
-    })
-], ActionModule);
-
-let StateModule = class StateModule {
-};
-StateModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                provide: DISPATCHER_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ stores }) => createDispatcher({ stores: stores && flatten(stores) }),
-                deps: {
-                    stores: {
-                        token: COMBINE_REDUCERS,
-                        optional: true,
-                    },
-                },
-            }),
-            provide({
-                provide: DISPATCHER_CONTEXT_TOKEN,
-                scope: Scope.REQUEST,
-                useFactory: ({ dispatcher, initialState, middlewares }) => {
-                    return dispatcher.createContext({}, initialState, [
-                        devTools.middleware(),
-                        ...flatten(middlewares || []),
-                    ]);
-                },
-                deps: {
-                    dispatcher: DISPATCHER_TOKEN,
-                    middlewares: { token: STORE_MIDDLEWARE, optional: true },
-                    initialState: { token: INITIAL_APP_STATE_TOKEN, optional: true },
-                },
-            }),
-            provide({
-                provide: STORE_TOKEN,
-                scope: Scope.REQUEST,
-                useFactory: ({ dispatcherContext }) => ({
-                    getState: dispatcherContext.getState.bind(dispatcherContext),
-                    dispatch: dispatcherContext.dispatch.bind(dispatcherContext),
-                    subscribe: dispatcherContext.subscribe.bind(dispatcherContext),
-                }),
-                deps: {
-                    dispatcherContext: DISPATCHER_CONTEXT_TOKEN,
-                },
-            }),
-        ],
-    })
-], StateModule);
-
-const cacheFactory = (type, options = { max: 100 }) => {
-    return new LRU(options);
-};
-
-const providers$1 = [];
-
-const cachesToken = createToken$1('_cachesList');
-let CacheModule = class CacheModule {
-};
-CacheModule = __decorate([
-    Module({
-        providers: [
-            ...providers$1,
-            {
-                provide: cachesToken,
-                scope: Scope.SINGLETON,
-                useValue: [],
-            },
-            {
-                provide: 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: IS_DI_CHILD_CONTAINER_TOKEN, optional: true },
-                },
-            },
-            {
-                provide: CLEAR_CACHE_TOKEN,
-                scope: 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: 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 ExecutionAbortError({
-                message: `Execution aborted in context "${contextName}"`,
-                contextName,
-            });
-        }
-        const abortController = new 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);
-            }
-        }
-    }
-}
-
-let CommonModule = class CommonModule {
-};
-CommonModule = __decorate([
-    Module({
-        imports: [
-            CommandModule,
-            EnvironmentModule,
-            PubSubModule,
-            LogModule,
-            CookieModule,
-            ActionModule,
-            StateModule,
-            RequestManagerModule,
-            ResponseManagerModule,
-            CacheModule,
-        ],
-        providers: [
-            provide({
-                // Инстанс хук системы
-                provide: HOOK_TOKEN,
-                scope: Scope.SINGLETON,
-                useClass: Hooks,
-            }),
-            provide({
-                // Регистр ui компонентов
-                provide: COMPONENT_REGISTRY_TOKEN,
-                scope: Scope.SINGLETON,
-                useClass: ComponentRegistry,
-                deps: {
-                    componentList: { token: 'componentDefaultList', optional: true },
-                },
-            }),
-            provide({
-                // Управление бандлами, хранение и получение
-                provide: BUNDLE_MANAGER_TOKEN,
-                scope: Scope.SINGLETON,
-                useFactory: ({ additionalBundleList, ...bundleManagerDeps }) => {
-                    additionalBundleList === null || additionalBundleList === void 0 ? void 0 : additionalBundleList.forEach((bundles) => {
-                        eachObj((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: BUNDLE_LIST_TOKEN,
-                    additionalBundleList: { token: ADDITIONAL_BUNDLE_TOKEN, optional: true },
-                    componentRegistry: COMPONENT_REGISTRY_TOKEN,
-                    actionRegistry: ACTION_REGISTRY_TOKEN,
-                    dispatcher: DISPATCHER_TOKEN,
-                    logger: LOGGER_TOKEN,
-                },
-            }),
-            provide({
-                //  Клиентский контекст исполнения
-                provide: CONTEXT_TOKEN,
-                scope: Scope.REQUEST,
-                useFactory: createConsumerContext,
-                deps: {
-                    di: DI_TOKEN,
-                    pubsub: PUBSUB_TOKEN,
-                    dispatcherContext: DISPATCHER_CONTEXT_TOKEN,
-                    store: STORE_TOKEN,
-                },
-            }),
-            provide({
-                provide: EXECUTION_CONTEXT_MANAGER_TOKEN,
-                useClass: ExecutionContextManager,
-            }),
-            ...providers$2,
-        ],
-    })
-], CommonModule);
-
-const providers = [
-    provide({
-        provide: INITIAL_APP_STATE_TOKEN,
-        useFactory: ({ commonState, config }) => {
-            return commonState[`${config.key}`];
-        },
-        deps: {
-            commonState: CHILD_APP_COMMON_INITIAL_STATE_TOKEN,
-            config: CHILD_APP_INTERNAL_CONFIG_TOKEN,
-        },
-    }),
-];
-
-const stateProviders = [
-    provide({
-        provide: CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: [DISPATCHER_TOKEN, STORE_TOKEN, CONTEXT_TOKEN],
-    }),
-];
-
-const command = {
-    customer: [
-        commandLineListTokens$1.customerStart,
-        commandLineListTokens$1.resolveUserDeps,
-        commandLineListTokens$1.resolvePageDeps,
-    ],
-    clear: [commandLineListTokens$1.clear],
-    spa: [
-        commandLineListTokens$1.resolveUserDeps,
-        commandLineListTokens$1.resolvePageDeps,
-        commandLineListTokens$1.spaTransition,
-    ],
-    afterSpa: [commandLineListTokens$1.afterSpaTransition],
-};
-const lines = {
-    server: command,
-    client: command,
-};
-const commandProviders = [
-    provide({
-        provide: CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: COMMAND_LINE_RUNNER_TOKEN,
-    }),
-    provide({
-        provide: COMMAND_LINES_TOKEN,
-        scope: Scope.SINGLETON,
-        useValue: lines,
-    }),
-];
-
-const actionsProviders = [
-    provide({
-        provide: CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
-        multi: true,
-        useValue: [ACTION_EXECUTION_TOKEN, ACTION_PAGE_RUNNER_TOKEN],
-    }),
-    provide({
-        provide: COMBINE_REDUCERS,
-        multi: true,
-        useValue: actionTramvaiReducer,
-    }),
-];
-
-let CommonChildAppModule = class CommonChildAppModule {
-};
-CommonChildAppModule = __decorate([
-    Module({
-        providers: [
-            ...providers,
-            ...stateProviders,
-            ...commandProviders,
-            ...actionsProviders,
-            provide({
-                provide: EXTEND_RENDER,
-                multi: true,
-                useFactory: ({ context }) => {
-                    const serverState = typeof window !== 'undefined' ? context.getState() : undefined;
-                    return (render) => {
-                        return (jsx(Provider, { context: context, serverState: serverState, children: render }));
-                    };
-                },
-                deps: {
-                    context: CONTEXT_TOKEN,
-                },
-            }),
-        ],
-    })
-], CommonChildAppModule);
-
-export { ActionExecution, CommandModule, CommonChildAppModule, CommonModule, ExecutionContextManager, alwaysCondition, createConsumerContext, onlyBrowser, onlyServer, pageBrowser, pageServer };
+export { COOKIE_MANAGER_TOKEN } from '@tramvai/module-cookie';
+export { alwaysCondition } from './actions/conditions/always.browser.js';
+export { onlyServer } from './actions/conditions/onlyServer.browser.js';
+export { onlyBrowser } from './actions/conditions/onlyBrowser.browser.js';
+export { pageServer } from './actions/conditions/pageServer.browser.js';
+export { pageBrowser } from './actions/conditions/pageBrowser.browser.js';