@tramvai/module-router 2.70.1 → 2.72.0

package/lib/index.browser.js

@@ -1,920 +1,9 @@
-import { provide, commandLineListTokens, createToken as createToken$1, Module, DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
-import { Provider, setLogger, NoSpaRouter, Router, useNavigate, useRoute } from '@tinkoff/router';
+export { NoSpaRouterModule } from './modules/no-spa.browser.js';
+export { SpaRouterModule } from './modules/spa.browser.js';
+export { RouterChildAppModule } from './modules/child-app.browser.js';
 export { Provider, useNavigate, useRoute, useRouter, useUrl } from '@tinkoff/router';
-import noop from '@tinkoff/utils/function/noop';
-import { LOGGER_TOKEN, BUNDLE_MANAGER_TOKEN, ACTION_REGISTRY_TOKEN, RESPONSE_MANAGER_TOKEN, DISPATCHER_TOKEN, DISPATCHER_CONTEXT_TOKEN, CONTEXT_TOKEN, COMPONENT_REGISTRY_TOKEN, COMBINE_REDUCERS, STORE_TOKEN, ACTION_PAGE_RUNNER_TOKEN } from '@tramvai/tokens-common';
-import { ROUTER_GUARD_TOKEN, PAGE_SERVICE_TOKEN, ROUTE_TRANSFORM_TOKEN, ROUTER_TOKEN, ROUTES_TOKEN, ROUTE_RESOLVE_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN } from '@tramvai/tokens-router';
+export { Link } from './components/link.browser.js';
 export * from '@tramvai/tokens-router';
-import { EXTEND_RENDER, TRAMVAI_RENDER_MODE } from '@tramvai/tokens-render';
-import { createEvent, createReducer } from '@tramvai/state';
-import flatten from '@tinkoff/utils/array/flatten';
-import { createToken, optional } from '@tinkoff/dippy';
-import isArray from '@tinkoff/utils/is/array';
-import { resolveLazyComponent, useDi } from '@tramvai/react';
-import identity from '@tinkoff/utils/function/identity';
-import compose from '@tinkoff/utils/function/compose';
-import replace from '@tinkoff/utils/string/replace';
-import { jsx } from 'react/jsx-runtime';
-import { isFileSystemPageComponent, fileSystemPagesEnabled, getStaticFileSystemPages, fileSystemPageToRoute } from '@tramvai/experiments';
-import { addQuery } from '@tinkoff/url';
-import uniq from '@tinkoff/utils/array/uniq';
-import { isRedirectFoundError, isNotFoundError } from '@tinkoff/errors';
-import { __decorate } from 'tslib';
-import { CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN } from '@tramvai/tokens-child-app';
-import { useEffect, useState, useCallback, isValidElement, cloneElement } from 'react';
-
-const setCurrentNavigation = createEvent('SET_CURRENT_ROUTE');
-const setUrlOnRehydrate = createEvent('SET_URL_ON_REHYDRATE');
-const initialState = {
-    currentRoute: null,
-    previousRoute: null,
-    currentUrl: null,
-    previousUrl: null,
-};
-const RouterStore = 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 routerClassToken = createToken('router routerClassToken');
-const additionalRouterParameters = createToken('router additionalParameters');
-const onChangeHooksToken = createToken('router onChangeHooks', {
-    multi: true,
-});
-const beforeResolveHooksToken = createToken('router beforeResolveHooks', {
-    multi: true,
-});
-const beforeNavigateHooksToken = createToken('router beforeNavigateHooks', {
-    multi: true,
-});
-const afterNavigateHooksToken = createToken('router afterNavigateHooks', {
-    multi: true,
-});
-const beforeUpdateCurrentHooksToken = createToken('router beforeUpdateCurrentHooks', { multi: true });
-const afterUpdateCurrentHooksToken = createToken('router afterUpdateCurrentHooks', { multi: true });
-const routeTransformToken = createToken('router finalRouteTransform');
-createToken('router bundleInfoAdditional');
-
-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(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(resolvedLayout.actions)) {
-                    actionRegistry.add(pageComponent, resolvedLayout.actions);
-                }
-                if ('reducers' in resolvedLayout && isArray(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: ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: loadBundle,
-        deps: {
-            logger: LOGGER_TOKEN,
-            bundleManager: BUNDLE_MANAGER_TOKEN,
-            actionRegistry: ACTION_REGISTRY_TOKEN,
-            responseManager: RESPONSE_MANAGER_TOKEN,
-            dispatcher: DISPATCHER_TOKEN,
-            dispatcherContext: DISPATCHER_CONTEXT_TOKEN,
-            pageService: PAGE_SERVICE_TOKEN,
-        },
-    },
-    {
-        provide: ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: internalError,
-        deps: {
-            logger: LOGGER_TOKEN,
-            responseManager: RESPONSE_MANAGER_TOKEN,
-        },
-    },
-];
-
-const fillRouterStore = ({ context, }) => {
-    return (navigation) => {
-        context.dispatch(setCurrentNavigation(navigation));
-    };
-};
-
-const commonHooks = [
-    {
-        provide: onChangeHooksToken,
-        multi: true,
-        useFactory: fillRouterStore,
-        deps: {
-            context: CONTEXT_TOKEN,
-        },
-    },
-];
-
-const routeTransform = ({ transformers, }) => {
-    if (!transformers || transformers.length === 0) {
-        return identity;
-    }
-    return compose(...flatten(transformers));
-};
-
-const routeSetDefaults = (route) => {
-    const config = {
-        bundle: 'mainDefault',
-        pageComponent: 'pageDefault',
-        ...route.config,
-    };
-    return {
-        ...route,
-        config,
-    };
-};
-
-const routeNormalize = (route) => {
-    return {
-        ...route,
-        path: replace(/\/?$/, '/', route.path),
-    };
-};
-
-const provideRouter = ({ router }) => {
-    const serverState = {
-        currentRoute: router.getCurrentRoute(),
-        currentUrl: router.getCurrentUrl(),
-    };
-    return (render) => {
-        return (jsx(Provider, { router: router, serverState: serverState, children: render }));
-    };
-};
-
-const commonTokens = [
-    {
-        provide: routeTransformToken,
-        useFactory: routeTransform,
-        deps: {
-            transformers: {
-                token: ROUTE_TRANSFORM_TOKEN,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: ROUTE_TRANSFORM_TOKEN,
-        multi: true,
-        useValue: routeSetDefaults,
-    },
-    {
-        provide: ROUTE_TRANSFORM_TOKEN,
-        multi: true,
-        useValue: routeNormalize,
-    },
-    {
-        provide: EXTEND_RENDER,
-        multi: true,
-        useFactory: provideRouter,
-        deps: {
-            router: 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 = isFileSystemPageComponent(pageComponent) ? pageComponent : bundle;
-        return group;
-    }
-}
-
-const providers$2 = [
-    fileSystemPagesEnabled() &&
-        provide({
-            provide: ROUTES_TOKEN,
-            multi: true,
-            useFactory: ({ logger }) => {
-                const log = logger('file-system-pages:route');
-                const pagesNames = Object.keys(getStaticFileSystemPages());
-                const routes = pagesNames.map(fileSystemPageToRoute);
-                log.debug({
-                    event: 'create static routes from file-system pages',
-                    routes,
-                });
-                return routes;
-            },
-            deps: {
-                logger: LOGGER_TOKEN,
-            },
-        }),
-].filter(Boolean);
-
-const providers$1 = [
-    ...commonGuards,
-    ...commonHooks,
-    ...commonTokens,
-    ...providers$2,
-    {
-        provide: ROUTER_TOKEN,
-        useFactory: ({ RouterClass, routes, routeTransform, routeResolve, additionalParameters, }) => {
-            const router = new RouterClass({
-                ...additionalParameters,
-                trailingSlash: true,
-                mergeSlashes: true,
-                routes: flatten(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: ROUTES_TOKEN,
-                optional: true,
-            },
-            routeTransform: routeTransformToken,
-            routeResolve: {
-                token: ROUTE_RESOLVE_TOKEN,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: commandLineListTokens.customerStart,
-        multi: true,
-        useFactory: ({ router, guards, onChange, beforeResolve, beforeNavigate, afterNavigate, beforeUpdateCurrent, afterUpdateCurrent, }) => {
-            return function routerInit() {
-                flatten(guards !== null && guards !== void 0 ? guards : []).forEach((guard) => router.registerGuard(guard));
-                flatten(onChange !== null && onChange !== void 0 ? onChange : []).forEach((hook) => router.registerSyncHook('change', hook));
-                flatten(beforeResolve !== null && beforeResolve !== void 0 ? beforeResolve : []).forEach((hook) => router.registerHook('beforeResolve', hook));
-                flatten(beforeNavigate !== null && beforeNavigate !== void 0 ? beforeNavigate : []).forEach((hook) => router.registerHook('beforeNavigate', hook));
-                flatten(afterNavigate !== null && afterNavigate !== void 0 ? afterNavigate : []).forEach((hook) => router.registerHook('afterNavigate', hook));
-                flatten(beforeUpdateCurrent !== null && beforeUpdateCurrent !== void 0 ? beforeUpdateCurrent : []).forEach((hook) => router.registerHook('beforeUpdateCurrent', hook));
-                flatten(afterUpdateCurrent !== null && afterUpdateCurrent !== void 0 ? afterUpdateCurrent : []).forEach((hook) => router.registerHook('afterUpdateCurrent', hook));
-            };
-        },
-        deps: {
-            router: ROUTER_TOKEN,
-            guards: {
-                token: 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: commandLineListTokens.init,
-        multi: true,
-        useFactory: ({ logger }) => {
-            return function routerSetLogger() {
-                setLogger(logger('route:router'));
-            };
-        },
-        deps: {
-            logger: LOGGER_TOKEN,
-        },
-    },
-    {
-        provide: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-        // TODO: пока делаем after т.к. на это рассчитывает большинство приложений и у нас пока нет механизма контроля выполнения экшенов, чтобы
-        // избежать случаев зависания перехода из-за долгих экшенов
-        // рассмотреть возможность замены после доработок экшенов
-        useValue: 'after',
-    },
-    provide({
-        provide: PAGE_SERVICE_TOKEN,
-        useClass: PageService,
-        deps: {
-            router: ROUTER_TOKEN,
-            componentRegistry: COMPONENT_REGISTRY_TOKEN,
-        },
-    }),
-    {
-        provide: COMBINE_REDUCERS,
-        multi: true,
-        useValue: RouterStore,
-    },
-];
-
-const PREFETCHED_LINKS_CACHE_TOKEN = createToken$1();
-const PREFETCHED_LINKS_QUEUE_TOKEN = createToken$1();
-const prefetchProviders = [
-    provide({
-        provide: PREFETCHED_LINKS_CACHE_TOKEN,
-        useValue: new Set(),
-    }),
-    provide({
-        provide: PREFETCHED_LINKS_QUEUE_TOKEN,
-        useFactory: () => {
-            let queue = Promise.resolve();
-            return {
-                add(run) {
-                    queue = queue.then(run);
-                    return queue;
-                },
-            };
-        },
-    }),
-    provide({
-        provide: LINK_PREFETCH_MANAGER_TOKEN,
-        useFactory: ({ router, routeTransform, routeResolve, componentRegistry, bundleManager, logger, prefetchedLinksCache, prefetchedLinksQueue, }) => {
-            const log = logger('link-prefetch-manager');
-            const prefetch = async (url) => {
-                // prefetch needed for cache assets by browser, so we want to prefetch resources for any page only once.
-                // cache will work only for SPA-router, but anyway resources loading deduplication logic already included in @loadable
-                if (prefetchedLinksCache.has(url)) {
-                    return;
-                }
-                prefetchedLinksCache.add(url);
-                log.info({ event: 'prefetch-route-init', url });
-                // first, try to find static or resolved dynamic route
-                let route = router.resolve(url);
-                // if route not found, try to resolve dynamic route,
-                // logic from `ROUTER_TOKEN` provider factory, without `router.addRoute` method call
-                if (!route && routeResolve) {
-                    // add query `prefetchRoute` to indicate to any `routeResolve` implementation
-                    // that this route request no need to be cached or have any personalization
-                    const parsedUrl = addQuery(url, { prefetchRoute: 'true' });
-                    route = await routeResolve({
-                        url: parsedUrl,
-                        type: 'navigate',
-                    });
-                    if (route) {
-                        route = routeTransform(route);
-                    }
-                }
-                if (!route) {
-                    log.info({ event: 'prefetch-route-not-found', url });
-                    return;
-                }
-                // @todo: очередь запросов!
-                // get name of everything what we need to prefetch,
-                // @loadable will load all scripts and styles for us
-                const { config: { pageComponent, bundle, nestedLayoutComponent }, } = route;
-                const promises = [];
-                // no need for bundle and page component actions amd reducers initialization,
-                // so copy only part of `modules/guards/common/loadBundle.ts` logic,
-                // all relative assets will be fetched
-                if (bundleManager.has(bundle, pageComponent)) {
-                    promises.push(bundleManager.get(bundle, pageComponent));
-                }
-                // no need for nestedLayoutComponent actions amd reducers initialization,
-                // so copy only part of `modules/guards/common/loadBundle.ts` logic,
-                // all relative assets will be fetched
-                if (nestedLayoutComponent) {
-                    promises.push(resolveLazyComponent(componentRegistry.get(nestedLayoutComponent, isFileSystemPageComponent(pageComponent) ? '__default' : bundle)));
-                }
-                await Promise.all(promises)
-                    .then(() => {
-                    log.info({ event: 'prefetch-route-success', url });
-                })
-                    .catch((error) => {
-                    log.warn({
-                        event: 'prefetch-fail',
-                        url,
-                        error,
-                    });
-                });
-            };
-            return {
-                prefetch: (url) => {
-                    // fetch assets sequentially
-                    return prefetchedLinksQueue.add(() => prefetch(url));
-                },
-            };
-        },
-        deps: {
-            router: ROUTER_TOKEN,
-            routeTransform: routeTransformToken,
-            routeResolve: {
-                token: ROUTE_RESOLVE_TOKEN,
-                optional: true,
-            },
-            componentRegistry: COMPONENT_REGISTRY_TOKEN,
-            bundleManager: BUNDLE_MANAGER_TOKEN,
-            logger: LOGGER_TOKEN,
-            prefetchedLinksCache: PREFETCHED_LINKS_CACHE_TOKEN,
-            prefetchedLinksQueue: PREFETCHED_LINKS_QUEUE_TOKEN,
-        },
-    }),
-];
-
-const clientTokens = [...prefetchProviders];
-
-const stopRunAtError = (error) => {
-    if (isNotFoundError(error) || 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([
-            ...(actionRegistry.getGlobal() || []),
-            ...(actionRegistry.get(bundle) || []),
-            ...(actionRegistry.get(pageComponent) || []),
-        ]);
-        return actionPageRunner.runActions(actions, stopRunAtError).catch((err) => {
-            if (isRedirectFoundError(err)) {
-                return router.navigate({
-                    url: err.nextUrl,
-                    replace: true,
-                    code: err.httpStatus,
-                });
-            }
-            throw err.error || err;
-        });
-    };
-};
-
-const providers = [
-    ...clientTokens,
-    ...providers$1,
-    provide({
-        provide: commandLineListTokens.customerStart,
-        multi: true,
-        useFactory: ({ router, store }) => {
-            return async function routerInit() {
-                const currentRoute = store.getState(RouterStore).currentRoute;
-                return router.rehydrate({
-                    to: currentRoute,
-                });
-            };
-        },
-        deps: {
-            router: ROUTER_TOKEN,
-            store: STORE_TOKEN,
-        },
-    }),
-    provide({
-        // после выполнения надо включить исполнение роутинга, чтобы регидрация рендера реакта прошла успешно
-        // после этого уже можно будет делать переходы и т.д.
-        provide: commandLineListTokens.clear,
-        multi: true,
-        useFactory: ({ router, store }) => {
-            return function routerStart() {
-                const routerState = store.getState().router;
-                if (routerState.currentUrl.href !== window.location.href) {
-                    store.dispatch(setUrlOnRehydrate(router.getCurrentUrl()));
-                }
-                return router.start();
-            };
-        },
-        deps: {
-            router: ROUTER_TOKEN,
-            store: STORE_TOKEN,
-        },
-    }),
-    provide({
-        // при первой загрузке страницы мы должны выполнить экшены уже после того произошла регидрация
-        // рендера реакта, т.к. экшены могут повлиять на рендер
-        provide: commandLineListTokens.clear,
-        multi: true,
-        useFactory: (deps) => {
-            const currentRoute = deps.store.getState(RouterStore).currentRoute;
-            // in client-side rendering mode, action will be executed on first navigation
-            if (deps.renderMode === 'client' &&
-                (!currentRoute || (currentRoute && currentRoute.actualPath !== window.location.pathname))) {
-                return noop;
-            }
-            return runActionsFactory(deps);
-        },
-        deps: {
-            store: STORE_TOKEN,
-            router: ROUTER_TOKEN,
-            actionRegistry: ACTION_REGISTRY_TOKEN,
-            actionPageRunner: ACTION_PAGE_RUNNER_TOKEN,
-            renderMode: TRAMVAI_RENDER_MODE,
-        },
-    }),
-    provide({
-        provide: commandLineListTokens.clear,
-        multi: true,
-        useFactory: ({ store, router, renderMode }) => {
-            return async function csrFirstNavigation() {
-                const currentRoute = store.getState(RouterStore).currentRoute;
-                // in client-side rendering mode, if current route inconsistent with current location,
-                // run navigation to current location.
-                if (renderMode === 'client' &&
-                    (!currentRoute || (currentRoute && currentRoute.actualPath !== window.location.pathname))) {
-                    // replace because otherwice we will push in the history the same url twice,
-                    // and history.back will return to the same url
-                    return router.navigate({ url: window.location.href, replace: true });
-                }
-            };
-        },
-        deps: {
-            store: STORE_TOKEN,
-            router: ROUTER_TOKEN,
-            renderMode: TRAMVAI_RENDER_MODE,
-        },
-    }),
-];
-
-const generateForRoot = (mainModule) => {
-    return (routes, options = {}) => {
-        return {
-            mainModule,
-            providers: [
-                {
-                    provide: ROUTES_TOKEN,
-                    multi: true,
-                    useValue: routes,
-                },
-                options.spaActionsMode && {
-                    provide: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                    useValue: options.spaActionsMode,
-                },
-            ].filter(Boolean),
-        };
-    };
-};
-
-var _a$1;
-const NoSpaRouterModule = /* @__PURE__ */ Module({
-    providers: [
-        ...providers,
-        {
-            provide: routerClassToken,
-            useValue: NoSpaRouter,
-        },
-    ],
-})((_a$1 = class NoSpaRouterModule {
-    },
-    _a$1.forRoot = generateForRoot(_a$1),
-    _a$1));
-
-const runCommandsSpa = ({ commandLineRunner, di, }) => {
-    return async () => {
-        await commandLineRunner.run('client', 'spa', [], di);
-    };
-};
-const runCommandsAfterSpa = ({ commandLineRunner, di, }) => {
-    return async () => {
-        await commandLineRunner.run('client', 'afterSpa', [], di);
-    };
-};
-
-const spaHooks = [
-    {
-        provide: beforeNavigateHooksToken,
-        multi: true,
-        useFactory: runCommandsSpa,
-        deps: {
-            di: DI_TOKEN,
-            commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
-        },
-    },
-    {
-        provide: afterNavigateHooksToken,
-        multi: true,
-        useFactory: runCommandsAfterSpa,
-        deps: {
-            di: DI_TOKEN,
-            commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
-        },
-    },
-    {
-        provide: commandLineListTokens.spaTransition,
-        multi: true,
-        useFactory: ({ spaMode, ...deps }) => {
-            if (spaMode !== 'after') {
-                return runActionsFactory(deps);
-            }
-            return noop;
-        },
-        deps: {
-            store: STORE_TOKEN,
-            router: ROUTER_TOKEN,
-            actionRegistry: ACTION_REGISTRY_TOKEN,
-            actionPageRunner: ACTION_PAGE_RUNNER_TOKEN,
-            spaMode: {
-                token: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                optional: true,
-            },
-        },
-    },
-    {
-        provide: commandLineListTokens.afterSpaTransition,
-        multi: true,
-        useFactory: ({ spaMode, ...deps }) => {
-            if (spaMode === 'after') {
-                return runActionsFactory(deps);
-            }
-            return noop;
-        },
-        deps: {
-            store: STORE_TOKEN,
-            router: ROUTER_TOKEN,
-            actionRegistry: ACTION_REGISTRY_TOKEN,
-            actionPageRunner: ACTION_PAGE_RUNNER_TOKEN,
-            spaMode: {
-                token: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                optional: true,
-            },
-        },
-    },
-];
-
-var _a;
-const SpaRouterModule = /* @__PURE__ */ Module({
-    providers: [
-        ...providers,
-        ...spaHooks,
-        {
-            provide: routerClassToken,
-            useValue: Router,
-        },
-    ],
-})((_a = class SpaRouterModule {
-    },
-    _a.forRoot = generateForRoot(_a),
-    _a));
-
-let RouterChildAppModule = class RouterChildAppModule {
-};
-RouterChildAppModule = __decorate([
-    Module({
-        providers: [
-            provide({
-                provide: EXTEND_RENDER,
-                multi: true,
-                useFactory: provideRouter,
-                deps: {
-                    router: ROUTER_TOKEN,
-                },
-            }),
-            {
-                provide: CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN,
-                multi: true,
-                useValue: RouterStore,
-            },
-        ],
-    })
-], RouterChildAppModule);
-
-const requestIdleCallback = window.requestIdleCallback ||
-    function (callback) {
-        return window.setTimeout(callback, 1);
-    };
-const cancelIdleCallback = window.cancelIdleCallback ||
-    function (timer) {
-        return window.clearTimeout(timer);
-    };
-
-const isUserNetworkConditionsSuitableForPrefetch = () => {
-    var _a;
-    const { saveData, effectiveType = '' } = (_a = navigator.connection) !== null && _a !== void 0 ? _a : {};
-    return !saveData && !(effectiveType === '2g' || effectiveType === 'slow-2g');
-};
-const usePrefetch = ({ url, target, prefetch, }) => {
-    const linkPrefetchManager = useDi(optional(LINK_PREFETCH_MANAGER_TOKEN));
-    useEffect(() => {
-        if (!target || !prefetch || !linkPrefetchManager) {
-            return;
-        }
-        let idleId = null;
-        const observer = new IntersectionObserver((entries) => {
-            entries.forEach((entry) => {
-                // when `Link` element in viewport
-                if (entry.isIntersecting && entry.intersectionRatio > 0) {
-                    // only once
-                    observer.disconnect();
-                    if (isUserNetworkConditionsSuitableForPrefetch()) {
-                        // trigger prefetching when browser is idle
-                        idleId = requestIdleCallback(() => {
-                            linkPrefetchManager.prefetch(url);
-                        });
-                    }
-                }
-            });
-        });
-        observer.observe(target);
-        return () => {
-            observer.disconnect();
-            cancelIdleCallback(idleId);
-        };
-    }, [url, target, prefetch, linkPrefetchManager]);
-};
-
-function Link(props) {
-    const { children, onClick, url, query, replace, target, navigateOptions, prefetch = true, ...otherProps } = props;
-    const navigate = useNavigate({ url, query, replace, ...navigateOptions });
-    const [linkElement, setLinkElement] = useState(null);
-    usePrefetch({
-        url,
-        prefetch,
-        target: linkElement,
-    });
-    const handleClick = 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 (isValidElement(children)) {
-        return 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
-    jsx("a", { ref: (element) => setLinkElement(element), ...otherProps, ...extraProps, children: children }));
-}
-Link.displayName = 'Link';
-
-const usePageService = () => {
-    useRoute();
-    return useDi(PAGE_SERVICE_TOKEN);
-};
-
-export { Link, NoSpaRouterModule, RouterChildAppModule, RouterStore, SpaRouterModule, generateForRoot, setCurrentNavigation, setUrlOnRehydrate, usePageService };
+export { generateForRoot } from './modules/utils/forRoot.browser.js';
+export { RouterStore, setCurrentNavigation, setUrlOnRehydrate } from './stores/RouterStore.browser.js';
+export { usePageService } from './hooks/usePageService.browser.js';