@tramvai/module-router 2.70.0 → 2.72.0

package/lib/index.js

@@ -2,809 +2,55 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
-var core = require('@tramvai/core');
+var server = require('./modules/server.js');
+var childApp = require('./modules/child-app.js');
 var router = require('@tinkoff/router');
-var tokensCommon = require('@tramvai/tokens-common');
+var link = require('./components/link.js');
 var tokensRouter = require('@tramvai/tokens-router');
-var flatten = require('@tinkoff/utils/array/flatten');
-var dippy = require('@tinkoff/dippy');
-var state = require('@tramvai/state');
-var isArray = require('@tinkoff/utils/is/array');
-var react = require('@tramvai/react');
-var tokensRender = require('@tramvai/tokens-render');
-var identity = require('@tinkoff/utils/function/identity');
-var compose = require('@tinkoff/utils/function/compose');
-var replace = require('@tinkoff/utils/string/replace');
-var jsxRuntime = require('react/jsx-runtime');
-var experiments = require('@tramvai/experiments');
-var uniq = require('@tinkoff/utils/array/uniq');
-var errors = require('@tinkoff/errors');
-var tokensServer = require('@tramvai/tokens-server');
-var prop = require('@tinkoff/utils/object/prop');
-var papi = require('@tramvai/papi');
-var tokensChildApp = require('@tramvai/tokens-child-app');
-var react$1 = require('react');
+var forRoot = require('./modules/utils/forRoot.js');
+var RouterStore = require('./stores/RouterStore.js');
+var usePageService = require('./hooks/usePageService.js');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
-var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
-var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
-var replace__default = /*#__PURE__*/_interopDefaultLegacy(replace);
-var uniq__default = /*#__PURE__*/_interopDefaultLegacy(uniq);
-var prop__default = /*#__PURE__*/_interopDefaultLegacy(prop);
 
-const routerClassToken = dippy.createToken('router routerClassToken');
-const additionalRouterParameters = dippy.createToken('router additionalParameters');
-const onChangeHooksToken = dippy.createToken('router onChangeHooks', {
-    multi: true,
+Object.defineProperty(exports, 'NoSpaRouterModule', {
+	enumerable: true,
+	get: function () { return server.NoSpaRouterModule; }
 });
-const beforeResolveHooksToken = dippy.createToken('router beforeResolveHooks', {
-    multi: true,
+exports.SpaRouterModule = server.SpaRouterModule;
+Object.defineProperty(exports, 'RouterChildAppModule', {
+	enumerable: true,
+	get: function () { return childApp.RouterChildAppModule; }
 });
-const beforeNavigateHooksToken = dippy.createToken('router beforeNavigateHooks', {
-    multi: true,
-});
-const afterNavigateHooksToken = dippy.createToken('router afterNavigateHooks', {
-    multi: true,
-});
-const beforeUpdateCurrentHooksToken = dippy.createToken('router beforeUpdateCurrentHooks', { multi: true });
-const afterUpdateCurrentHooksToken = dippy.createToken('router afterUpdateCurrentHooks', { multi: true });
-const routeTransformToken = dippy.createToken('router finalRouteTransform');
-const routerBundleInfoAdditionalToken = dippy.createToken('router bundleInfoAdditional');
-
-const setCurrentNavigation = state.createEvent('SET_CURRENT_ROUTE');
-const setUrlOnRehydrate = state.createEvent('SET_URL_ON_REHYDRATE');
-const initialState = {
-    currentRoute: null,
-    previousRoute: null,
-    currentUrl: null,
-    previousUrl: null,
-};
-const RouterStore = state.createReducer('router', initialState)
-    .on(setCurrentNavigation, (state, { to, from, url, fromUrl, replace }) => {
-    // TODO: убедиться что все данные нам нужны из роутинга,
-    // возможно всякие meta, content не нужны при дегидрации
-    return {
-        currentRoute: to,
-        previousRoute: replace ? state.previousRoute : from,
-        currentUrl: url,
-        previousUrl: replace ? state.previousUrl : fromUrl,
-    };
-})
-    .on(setUrlOnRehydrate, (state, url) => {
-    return {
-        ...state,
-        currentUrl: url,
-    };
-});
-
-const loadBundle = ({ bundleManager, logger, actionRegistry, responseManager, dispatcher, dispatcherContext, pageService, }) => {
-    const log = logger('route:load-bundles');
-    return async ({ to }) => {
-        var _a;
-        log.debug({
-            event: 'load-bundle',
-            route: to,
-        });
-        const { bundle, pageComponent, nestedLayoutComponent } = to.config;
-        if (!bundleManager.has(bundle, pageComponent)) {
-            log.info({
-                event: 'load-bundle-not-found',
-                bundle,
-                pageComponent,
-            });
-            // если бандл не найден, то всё ок и мы должны вернуть 404 на сервере,
-            // а на клиенте просто загрузить новую страницу
-            responseManager.setStatus(404);
-            return false;
-        }
-        // Пытаемся загрузить и в случае инициализации на клиенте, т.к.
-        // несмотря на наличие бандла в разметке, все равно мы должны дождаться
-        // его загрузки перед рендером
-        try {
-            const promises = [];
-            // for file-system pages bundle is virtual, so it will be loaded in parallel with nested layout
-            // for classic bundles, page component will be loaded after bundle loading
-            promises.push(bundleManager.get(bundle, pageComponent));
-            if (nestedLayoutComponent) {
-                promises.push(react.resolveLazyComponent(pageService.resolveComponentFromConfig('nestedLayout')));
-            }
-            const [resolvedBundle, resolvedLayout] = await Promise.all(promises);
-            const { components, reducers } = resolvedBundle;
-            const component = components[pageComponent];
-            // pageComponent should have required fields even if it is lazy,
-            // thanks to `git log 9466cb32bfb71ba49144ef839d3d5bce246e213c -L90,103:packages/modules/common/src/bundleManager/bundleManager.ts`
-            (_a = component === null || component === void 0 ? void 0 : component.reducers) === null || _a === void 0 ? void 0 : _a.forEach((reducer) => dispatcherContext.getStore(reducer));
-            reducers === null || reducers === void 0 ? void 0 : reducers.forEach((reducer) => dispatcherContext.getStore(reducer));
-            // @todo: reuse logic from bundleManager?
-            // register nested layout actions and reducers for current page
-            if (resolvedLayout) {
-                if ('actions' in resolvedLayout && isArray__default["default"](resolvedLayout.actions)) {
-                    actionRegistry.add(pageComponent, resolvedLayout.actions);
-                }
-                if ('reducers' in resolvedLayout && isArray__default["default"](resolvedLayout.reducers)) {
-                    resolvedLayout.reducers.forEach((reducer) => {
-                        dispatcher.registerStore(reducer);
-                        dispatcherContext.getStore(reducer);
-                    });
-                }
-            }
-        }
-        catch (error) {
-            log.error({
-                event: 'load-bundle-failed',
-                error,
-            });
-            // блокируем переход если не удалось загрузить бандл
-            return false;
-        }
-    };
-};
-
-const internalError = ({ responseManager, logger, }) => {
-    const log = logger('route:guard-check-error');
-    return async () => {
-        if (responseManager.getStatus() >= 500) {
-            log.error({
-                event: 'status-is-error',
-                status: responseManager.getStatus(),
-            });
-            return false;
-        }
-    };
-};
-
-const commonGuards = [
-    {
-        provide: tokensRouter.ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: loadBundle,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            bundleManager: tokensCommon.BUNDLE_MANAGER_TOKEN,
-            actionRegistry: tokensCommon.ACTION_REGISTRY_TOKEN,
-            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-            dispatcher: tokensCommon.DISPATCHER_TOKEN,
-            dispatcherContext: tokensCommon.DISPATCHER_CONTEXT_TOKEN,
-            pageService: tokensRouter.PAGE_SERVICE_TOKEN,
-        },
-    },
-    {
-        provide: tokensRouter.ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: internalError,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-        },
-    },
-];
-
-const fillRouterStore = ({ context, }) => {
-    return (navigation) => {
-        context.dispatch(setCurrentNavigation(navigation));
-    };
-};
-
-const commonHooks = [
-    {
-        provide: onChangeHooksToken,
-        multi: true,
-        useFactory: fillRouterStore,
-        deps: {
-            context: tokensCommon.CONTEXT_TOKEN,
-        },
-    },
-];
-
-const routeTransform = ({ transformers, }) => {
-    if (!transformers || transformers.length === 0) {
-        return identity__default["default"];
-    }
-    return compose__default["default"](...flatten__default["default"](transformers));
-};
-
-const routeSetDefaults = (route) => {
-    const config = {
-        bundle: 'mainDefault',
-        pageComponent: 'pageDefault',
-        ...route.config,
-    };
-    return {
-        ...route,
-        config,
-    };
-};
-
-const routeNormalize = (route) => {
-    return {
-        ...route,
-        path: replace__default["default"](/\/?$/, '/', route.path),
-    };
-};
-
-const provideRouter = ({ router: router$1 }) => {
-    const serverState = {
-        currentRoute: router$1.getCurrentRoute(),
-        currentUrl: router$1.getCurrentUrl(),
-    };
-    return (render) => {
-        return (jsxRuntime.jsx(router.Provider, { router: router$1, serverState: serverState, children: render }));
-    };
-};
-
-const commonTokens = [
-    {
-        provide: routeTransformToken,
-        useFactory: routeTransform,
-        deps: {
-            transformers: {
-                token: tokensRouter.ROUTE_TRANSFORM_TOKEN,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: tokensRouter.ROUTE_TRANSFORM_TOKEN,
-        multi: true,
-        useValue: routeSetDefaults,
-    },
-    {
-        provide: tokensRouter.ROUTE_TRANSFORM_TOKEN,
-        multi: true,
-        useValue: routeNormalize,
-    },
-    {
-        provide: tokensRender.EXTEND_RENDER,
-        multi: true,
-        useFactory: provideRouter,
-        deps: {
-            router: tokensRouter.ROUTER_TOKEN,
-        },
-    },
-];
-
-class PageService {
-    constructor({ router, componentRegistry }) {
-        this.router = router;
-        this.componentRegistry = componentRegistry;
-    }
-    getCurrentRoute() {
-        return this.router.getCurrentRoute();
-    }
-    getCurrentUrl() {
-        return this.router.getCurrentUrl();
-    }
-    getConfig() {
-        var _a, _b;
-        return (_b = (_a = this.getCurrentRoute()) === null || _a === void 0 ? void 0 : _a.config) !== null && _b !== void 0 ? _b : {};
-    }
-    getContent() {
-        var _a;
-        return (_a = this.getConfig().content) !== null && _a !== void 0 ? _a : {};
-    }
-    getMeta() {
-        var _a;
-        return (_a = this.getConfig().meta) !== null && _a !== void 0 ? _a : {};
-    }
-    navigate(options) {
-        return this.router.navigate(options);
-    }
-    updateCurrentRoute(options) {
-        return this.router.updateCurrentRoute(options);
-    }
-    back(options) {
-        return this.router.back(options);
-    }
-    forward() {
-        return this.router.forward();
-    }
-    go(to, options) {
-        return this.router.go(to, options);
-    }
-    addComponent(name, component) {
-        const group = this.getComponentsGroupName();
-        return this.componentRegistry.add(name, component, group);
-    }
-    getComponent(name) {
-        const group = this.getComponentsGroupName();
-        return this.componentRegistry.get(name, group);
-    }
-    resolveComponentFromConfig(property) {
-        var _a;
-        const configName = `${property}Component`;
-        const defaultComponent = `${property}Default`;
-        const componentName = (_a = this.getConfig()[configName]) !== null && _a !== void 0 ? _a : defaultComponent;
-        return this.getComponent(componentName) || this.getComponent(defaultComponent);
-    }
-    getComponentsGroupName() {
-        const { bundle, pageComponent } = this.getConfig();
-        const group = experiments.isFileSystemPageComponent(pageComponent) ? pageComponent : bundle;
-        return group;
-    }
-}
-
-const providers$1 = [
-    experiments.fileSystemPagesEnabled() &&
-        core.provide({
-            provide: tokensRouter.ROUTES_TOKEN,
-            multi: true,
-            useFactory: ({ logger }) => {
-                const log = logger('file-system-pages:route');
-                const pagesNames = Object.keys(experiments.getStaticFileSystemPages());
-                const routes = pagesNames.map(experiments.fileSystemPageToRoute);
-                log.debug({
-                    event: 'create static routes from file-system pages',
-                    routes,
-                });
-                return routes;
-            },
-            deps: {
-                logger: tokensCommon.LOGGER_TOKEN,
-            },
-        }),
-].filter(Boolean);
-
-const providers = [
-    ...commonGuards,
-    ...commonHooks,
-    ...commonTokens,
-    ...providers$1,
-    {
-        provide: tokensRouter.ROUTER_TOKEN,
-        useFactory: ({ RouterClass, routes, routeTransform, routeResolve, additionalParameters, }) => {
-            const router = new RouterClass({
-                ...additionalParameters,
-                trailingSlash: true,
-                mergeSlashes: true,
-                routes: flatten__default["default"](routes !== null && routes !== void 0 ? routes : []).map(routeTransform),
-            });
-            if (routeResolve) {
-                router.registerHook('beforeResolve', async (navigation) => {
-                    if (!router.resolve(navigation.url.href)) {
-                        const route = await routeResolve(navigation);
-                        if (route) {
-                            router.addRoute(routeTransform(route));
-                        }
-                    }
-                });
-            }
-            return router;
-        },
-        deps: {
-            RouterClass: routerClassToken,
-            additionalParameters: {
-                token: additionalRouterParameters,
-                optional: true,
-            },
-            routes: {
-                token: tokensRouter.ROUTES_TOKEN,
-                optional: true,
-            },
-            routeTransform: routeTransformToken,
-            routeResolve: {
-                token: tokensRouter.ROUTE_RESOLVE_TOKEN,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: core.commandLineListTokens.customerStart,
-        multi: true,
-        useFactory: ({ router, guards, onChange, beforeResolve, beforeNavigate, afterNavigate, beforeUpdateCurrent, afterUpdateCurrent, }) => {
-            return function routerInit() {
-                flatten__default["default"](guards !== null && guards !== void 0 ? guards : []).forEach((guard) => router.registerGuard(guard));
-                flatten__default["default"](onChange !== null && onChange !== void 0 ? onChange : []).forEach((hook) => router.registerSyncHook('change', hook));
-                flatten__default["default"](beforeResolve !== null && beforeResolve !== void 0 ? beforeResolve : []).forEach((hook) => router.registerHook('beforeResolve', hook));
-                flatten__default["default"](beforeNavigate !== null && beforeNavigate !== void 0 ? beforeNavigate : []).forEach((hook) => router.registerHook('beforeNavigate', hook));
-                flatten__default["default"](afterNavigate !== null && afterNavigate !== void 0 ? afterNavigate : []).forEach((hook) => router.registerHook('afterNavigate', hook));
-                flatten__default["default"](beforeUpdateCurrent !== null && beforeUpdateCurrent !== void 0 ? beforeUpdateCurrent : []).forEach((hook) => router.registerHook('beforeUpdateCurrent', hook));
-                flatten__default["default"](afterUpdateCurrent !== null && afterUpdateCurrent !== void 0 ? afterUpdateCurrent : []).forEach((hook) => router.registerHook('afterUpdateCurrent', hook));
-            };
-        },
-        deps: {
-            router: tokensRouter.ROUTER_TOKEN,
-            guards: {
-                token: tokensRouter.ROUTER_GUARD_TOKEN,
-                optional: true,
-            },
-            onChange: {
-                token: onChangeHooksToken,
-                optional: true,
-            },
-            beforeResolve: {
-                token: beforeResolveHooksToken,
-                optional: true,
-            },
-            beforeNavigate: {
-                token: beforeNavigateHooksToken,
-                optional: true,
-            },
-            afterNavigate: {
-                token: afterNavigateHooksToken,
-                optional: true,
-            },
-            beforeUpdateCurrent: {
-                token: beforeUpdateCurrentHooksToken,
-                optional: true,
-            },
-            afterUpdateCurrent: {
-                token: afterUpdateCurrentHooksToken,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: core.commandLineListTokens.init,
-        multi: true,
-        useFactory: ({ logger }) => {
-            return function routerSetLogger() {
-                router.setLogger(logger('route:router'));
-            };
-        },
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-        },
-    },
-    {
-        provide: tokensRouter.ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-        // TODO: пока делаем after т.к. на это рассчитывает большинство приложений и у нас пока нет механизма контроля выполнения экшенов, чтобы
-        // избежать случаев зависания перехода из-за долгих экшенов
-        // рассмотреть возможность замены после доработок экшенов
-        useValue: 'after',
-    },
-    core.provide({
-        provide: tokensRouter.PAGE_SERVICE_TOKEN,
-        useClass: PageService,
-        deps: {
-            router: tokensRouter.ROUTER_TOKEN,
-            componentRegistry: tokensCommon.COMPONENT_REGISTRY_TOKEN,
-        },
-    }),
-    {
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: RouterStore,
-    },
-];
-
-const httpMethod = ({ requestManager, responseManager, logger, }) => {
-    const log = logger('route:httpMethod');
-    return async ({ to }) => {
-        const { httpMethods } = to.config;
-        if (httpMethods) {
-            const currentMethod = requestManager.getMethod().toLowerCase();
-            if (!httpMethods.split(',').includes(currentMethod)) {
-                log.info({
-                    event: 'check-failed',
-                    currentMethod,
-                    route: to,
-                });
-                responseManager.setStatus(405);
-                return false;
-            }
-        }
-    };
-};
-
-const serverGuards = [
-    {
-        provide: tokensRouter.ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: httpMethod,
-        deps: {
-            requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
-            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-            logger: tokensCommon.LOGGER_TOKEN,
-        },
-    },
-];
-
-const stopRunAtError = (error) => {
-    if (errors.isNotFoundError(error) || errors.isRedirectFoundError(error)) {
-        return true;
-    }
-};
-const runActionsFactory = ({ store, router, actionRegistry, actionPageRunner, }) => {
-    return function runActions() {
-        const route = router.getCurrentRoute();
-        const { config: { bundle, pageComponent } = {} } = route;
-        if (!bundle || !pageComponent) {
-            throw new Error(`bundle and pageComponent should be defined, but got ${route}`);
-        }
-        const actions = uniq__default["default"]([
-            ...(actionRegistry.getGlobal() || []),
-            ...(actionRegistry.get(bundle) || []),
-            ...(actionRegistry.get(pageComponent) || []),
-        ]);
-        return actionPageRunner.runActions(actions, stopRunAtError).catch((err) => {
-            if (errors.isRedirectFoundError(err)) {
-                return router.navigate({
-                    url: err.nextUrl,
-                    replace: true,
-                    code: err.httpStatus,
-                });
-            }
-            throw err.error || err;
-        });
-    };
-};
-
-const httpStatus = ({ responseManager }) => async ({ to }) => {
-    if (to === null || to === void 0 ? void 0 : to.config.httpStatus) {
-        responseManager.setStatus(to.config.httpStatus);
-    }
-};
-
-const serverHooks = [
-    {
-        provide: afterNavigateHooksToken,
-        multi: true,
-        // проставляет httpStatus если задан в текущем роуте
-        useFactory: httpStatus,
-        deps: {
-            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-        },
-    },
-];
-
-const routerOptions = ({ requestManager, responseManager, }) => {
-    const getUrl = (navigation) => { var _a, _b; return (_b = (_a = navigation.url) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : requestManager.getUrl(); };
-    const throwError = ({ defaultStatus, url }) => {
-        const error = new errors.HttpError({
-            url,
-            httpStatus: responseManager.getStatus() >= 300 ? responseManager.getStatus() : defaultStatus,
-        });
-        errors.makeErrorSilent(error);
-        throw error;
-    };
-    return {
-        onNotFound: async (navigation) => {
-            // isSilent is used to prevent command line error logs,
-            // because 404 errors is expected behavior
-            throwError({ defaultStatus: 404, url: getUrl(navigation) });
-        },
-        onRedirect: async (navigation) => {
-            const { fromUrl, url, code } = navigation;
-            const error = new errors.RedirectFoundError({
-                url: getUrl(navigation),
-                nextUrl: fromUrl.origin !== url.origin ? url.href : url.path,
-                httpStatus: code,
-                silent: true,
-            });
-            errors.makeErrorSilent(error);
-            throw error;
-        },
-        onBlock: async (navigation) => {
-            throwError({ defaultStatus: 500, url: getUrl(navigation) });
-        },
-        defaultRedirectCode: requestManager.getMethod() === 'GET' ? 301 : 308,
-    };
-};
-
-const deduplicateArray = (list) => {
-    return Array.from(new Set(list));
-};
-const bundleInfoPapi = papi.createPapiMethod({
-    method: 'get',
-    path: '/bundleInfo',
-    async handler() {
-        var _a;
-        const { getAdditionalRoutes, routes, routeTransform } = this.deps;
-        const loadAdditional = getAdditionalRoutes !== null && getAdditionalRoutes !== void 0 ? getAdditionalRoutes : (() => []);
-        return deduplicateArray(flatten__default["default"](routes || [])
-            .concat((_a = (await loadAdditional())) !== null && _a !== void 0 ? _a : [])
-            .map(routeTransform)
-            .map(prop__default["default"]('path'))
-            .filter((path) => !router.isWildcard(path) && !router.isHistoryFallback(path))
-            .sort());
-    },
-    deps: {
-        routes: {
-            token: tokensRouter.ROUTES_TOKEN,
-            optional: true,
-        },
-        routeTransform: routeTransformToken,
-        getAdditionalRoutes: { token: routerBundleInfoAdditionalToken, optional: true },
-    },
-});
-
-// do nothing on server side
-const prefetchManager = {
-    prefetch: async (url) => { },
-};
-const prefetchProviders = [
-    core.provide({
-        provide: tokensRouter.LINK_PREFETCH_MANAGER_TOKEN,
-        useValue: prefetchManager,
-    }),
-];
-
-const serverTokens = [
-    {
-        provide: additionalRouterParameters,
-        useFactory: routerOptions,
-        deps: {
-            requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
-            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
-        },
-    },
-    {
-        provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-        multi: true,
-        useValue: bundleInfoPapi,
-    },
-    ...prefetchProviders,
-];
-
-const generateForRoot = (mainModule) => {
-    return (routes, options = {}) => {
-        return {
-            mainModule,
-            providers: [
-                {
-                    provide: tokensRouter.ROUTES_TOKEN,
-                    multi: true,
-                    useValue: routes,
-                },
-                options.spaActionsMode && {
-                    provide: tokensRouter.ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                    useValue: options.spaActionsMode,
-                },
-            ].filter(Boolean),
-        };
-    };
-};
-
-var NoSpaRouterModule_1;
-exports.NoSpaRouterModule = NoSpaRouterModule_1 = class NoSpaRouterModule {
-};
-exports.NoSpaRouterModule.forRoot = generateForRoot(NoSpaRouterModule_1);
-exports.NoSpaRouterModule = NoSpaRouterModule_1 = tslib.__decorate([
-    core.Module({
-        providers: [
-            ...providers,
-            ...serverGuards,
-            ...serverHooks,
-            ...serverTokens,
-            {
-                provide: routerClassToken,
-                useValue: router.Router,
-            },
-            {
-                provide: core.commandLineListTokens.resolveUserDeps,
-                multi: true,
-                useFactory: ({ router, requestManager }) => {
-                    return function routerInit() {
-                        return router.navigate(requestManager.getUrl());
-                    };
-                },
-                deps: {
-                    router: tokensRouter.ROUTER_TOKEN,
-                    requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
-                },
-            },
-            {
-                // запускаем экшены отдельно от самого роутинга, чтобы распараллелить задачи
-                provide: core.commandLineListTokens.resolvePageDeps,
-                multi: true,
-                useFactory: runActionsFactory,
-                deps: {
-                    store: tokensCommon.STORE_TOKEN,
-                    router: tokensRouter.ROUTER_TOKEN,
-                    actionRegistry: tokensCommon.ACTION_REGISTRY_TOKEN,
-                    actionPageRunner: tokensCommon.ACTION_PAGE_RUNNER_TOKEN,
-                },
-            },
-        ],
-    })
-], exports.NoSpaRouterModule);
-const SpaRouterModule = exports.NoSpaRouterModule;
-
-exports.RouterChildAppModule = class RouterChildAppModule {
-};
-exports.RouterChildAppModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            core.provide({
-                provide: tokensRender.EXTEND_RENDER,
-                multi: true,
-                useFactory: provideRouter,
-                deps: {
-                    router: tokensRouter.ROUTER_TOKEN,
-                },
-            }),
-            {
-                provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN,
-                multi: true,
-                useValue: RouterStore,
-            },
-        ],
-    })
-], exports.RouterChildAppModule);
-
-function Link(props) {
-    const { children, onClick, url, query, replace, target, navigateOptions, prefetch = true, ...otherProps } = props;
-    const navigate = router.useNavigate({ url, query, replace, ...navigateOptions });
-    const [linkElement, setLinkElement] = react$1.useState(null);
-    const handleClick = react$1.useCallback((event) => {
-        // ignores the navigation when clicked using right mouse button or
-        // by holding a special modifier key: ctrl, command, win, alt, shift
-        if (target ||
-            event.ctrlKey ||
-            event.metaKey ||
-            event.altKey ||
-            event.shiftKey ||
-            event.button !== 0) {
-            return;
-        }
-        event.preventDefault();
-        navigate();
-        onClick && onClick(event);
-    }, [navigate, target, onClick]);
-    const extraProps = { href: url, onClick: handleClick, target };
-    if (react$1.isValidElement(children)) {
-        return react$1.cloneElement(children, {
-            // @ts-expect-error
-            ref: (element) => {
-                // @ts-expect-error
-                const { ref } = children;
-                // preserve original ref
-                if (typeof ref === 'function') {
-                    ref(element);
-                }
-                else if (typeof ref === 'object' && ref !== null) {
-                    ref.current = element;
-                }
-                setLinkElement(element);
-            },
-            ...extraProps,
-        });
-    }
-    return (
-    // eslint-disable-next-line react/jsx-props-no-spreading
-    jsxRuntime.jsx("a", { ref: (element) => setLinkElement(element), ...otherProps, ...extraProps, children: children }));
-}
-Link.displayName = 'Link';
-
-const usePageService = () => {
-    router.useRoute();
-    return react.useDi(tokensRouter.PAGE_SERVICE_TOKEN);
-};
-
 Object.defineProperty(exports, 'Provider', {
-    enumerable: true,
-    get: function () { return router.Provider; }
+	enumerable: true,
+	get: function () { return router.Provider; }
 });
 Object.defineProperty(exports, 'useNavigate', {
-    enumerable: true,
-    get: function () { return router.useNavigate; }
+	enumerable: true,
+	get: function () { return router.useNavigate; }
 });
 Object.defineProperty(exports, 'useRoute', {
-    enumerable: true,
-    get: function () { return router.useRoute; }
+	enumerable: true,
+	get: function () { return router.useRoute; }
 });
 Object.defineProperty(exports, 'useRouter', {
-    enumerable: true,
-    get: function () { return router.useRouter; }
+	enumerable: true,
+	get: function () { return router.useRouter; }
 });
 Object.defineProperty(exports, 'useUrl', {
-    enumerable: true,
-    get: function () { return router.useUrl; }
-});
-exports.Link = Link;
-exports.RouterStore = RouterStore;
-exports.SpaRouterModule = SpaRouterModule;
-exports.generateForRoot = generateForRoot;
-exports.setCurrentNavigation = setCurrentNavigation;
-exports.setUrlOnRehydrate = setUrlOnRehydrate;
-exports.usePageService = usePageService;
+	enumerable: true,
+	get: function () { return router.useUrl; }
+});
+exports.Link = link.Link;
+exports.generateForRoot = forRoot.generateForRoot;
+exports.RouterStore = RouterStore.RouterStore;
+exports.setCurrentNavigation = RouterStore.setCurrentNavigation;
+exports.setUrlOnRehydrate = RouterStore.setUrlOnRehydrate;
+exports.usePageService = usePageService.usePageService;
 Object.keys(tokensRouter).forEach(function (k) {
-    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-        enumerable: true,
-        get: function () { return tokensRouter[k]; }
-    });
+	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return tokensRouter[k]; }
+	});
 });