@tramvai/module-router 2.70.0 → 2.72.0

package/lib/index.es.js

@@ -1,766 +1,8 @@
-import { __decorate } from 'tslib';
-import { provide, commandLineListTokens, Module } from '@tramvai/core';
-import { Provider, setLogger, isWildcard, isHistoryFallback, Router, useNavigate, useRoute } from '@tinkoff/router';
+export { NoSpaRouterModule, SpaRouterModule } from './modules/server.es.js';
+export { RouterChildAppModule } from './modules/child-app.es.js';
 export { Provider, useNavigate, useRoute, useRouter, useUrl } from '@tinkoff/router';
-import { LOGGER_TOKEN, BUNDLE_MANAGER_TOKEN, ACTION_REGISTRY_TOKEN, RESPONSE_MANAGER_TOKEN, DISPATCHER_TOKEN, DISPATCHER_CONTEXT_TOKEN, CONTEXT_TOKEN, COMPONENT_REGISTRY_TOKEN, COMBINE_REDUCERS, REQUEST_MANAGER_TOKEN, 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.es.js';
 export * from '@tramvai/tokens-router';
-import flatten from '@tinkoff/utils/array/flatten';
-import { createToken } from '@tinkoff/dippy';
-import { createEvent, createReducer } from '@tramvai/state';
-import isArray from '@tinkoff/utils/is/array';
-import { resolveLazyComponent, useDi } from '@tramvai/react';
-import { EXTEND_RENDER } from '@tramvai/tokens-render';
-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 uniq from '@tinkoff/utils/array/uniq';
-import { isRedirectFoundError, isNotFoundError, RedirectFoundError, makeErrorSilent, HttpError } from '@tinkoff/errors';
-import { SERVER_MODULE_PAPI_PUBLIC_ROUTE } from '@tramvai/tokens-server';
-import prop from '@tinkoff/utils/object/prop';
-import { createPapiMethod } from '@tramvai/papi';
-import { CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN } from '@tramvai/tokens-child-app';
-import { useState, useCallback, isValidElement, cloneElement } from 'react';
-
-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');
-const routerBundleInfoAdditionalToken = createToken('router bundleInfoAdditional');
-
-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 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$1 = [
-    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 = [
-    ...commonGuards,
-    ...commonHooks,
-    ...commonTokens,
-    ...providers$1,
-    {
-        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 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: ROUTER_GUARD_TOKEN,
-        multi: true,
-        useFactory: httpMethod,
-        deps: {
-            requestManager: REQUEST_MANAGER_TOKEN,
-            responseManager: RESPONSE_MANAGER_TOKEN,
-            logger: LOGGER_TOKEN,
-        },
-    },
-];
-
-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 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: 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 HttpError({
-            url,
-            httpStatus: responseManager.getStatus() >= 300 ? responseManager.getStatus() : defaultStatus,
-        });
-        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 RedirectFoundError({
-                url: getUrl(navigation),
-                nextUrl: fromUrl.origin !== url.origin ? url.href : url.path,
-                httpStatus: code,
-                silent: true,
-            });
-            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 = 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(routes || [])
-            .concat((_a = (await loadAdditional())) !== null && _a !== void 0 ? _a : [])
-            .map(routeTransform)
-            .map(prop('path'))
-            .filter((path) => !isWildcard(path) && !isHistoryFallback(path))
-            .sort());
-    },
-    deps: {
-        routes: {
-            token: ROUTES_TOKEN,
-            optional: true,
-        },
-        routeTransform: routeTransformToken,
-        getAdditionalRoutes: { token: routerBundleInfoAdditionalToken, optional: true },
-    },
-});
-
-// do nothing on server side
-const prefetchManager = {
-    prefetch: async (url) => { },
-};
-const prefetchProviders = [
-    provide({
-        provide: LINK_PREFETCH_MANAGER_TOKEN,
-        useValue: prefetchManager,
-    }),
-];
-
-const serverTokens = [
-    {
-        provide: additionalRouterParameters,
-        useFactory: routerOptions,
-        deps: {
-            requestManager: REQUEST_MANAGER_TOKEN,
-            responseManager: RESPONSE_MANAGER_TOKEN,
-        },
-    },
-    {
-        provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-        multi: true,
-        useValue: bundleInfoPapi,
-    },
-    ...prefetchProviders,
-];
-
-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 NoSpaRouterModule_1;
-let NoSpaRouterModule = NoSpaRouterModule_1 = class NoSpaRouterModule {
-};
-NoSpaRouterModule.forRoot = generateForRoot(NoSpaRouterModule_1);
-NoSpaRouterModule = NoSpaRouterModule_1 = __decorate([
-    Module({
-        providers: [
-            ...providers,
-            ...serverGuards,
-            ...serverHooks,
-            ...serverTokens,
-            {
-                provide: routerClassToken,
-                useValue: Router,
-            },
-            {
-                provide: commandLineListTokens.resolveUserDeps,
-                multi: true,
-                useFactory: ({ router, requestManager }) => {
-                    return function routerInit() {
-                        return router.navigate(requestManager.getUrl());
-                    };
-                },
-                deps: {
-                    router: ROUTER_TOKEN,
-                    requestManager: REQUEST_MANAGER_TOKEN,
-                },
-            },
-            {
-                // запускаем экшены отдельно от самого роутинга, чтобы распараллелить задачи
-                provide: commandLineListTokens.resolvePageDeps,
-                multi: true,
-                useFactory: runActionsFactory,
-                deps: {
-                    store: STORE_TOKEN,
-                    router: ROUTER_TOKEN,
-                    actionRegistry: ACTION_REGISTRY_TOKEN,
-                    actionPageRunner: ACTION_PAGE_RUNNER_TOKEN,
-                },
-            },
-        ],
-    })
-], NoSpaRouterModule);
-const SpaRouterModule = NoSpaRouterModule;
-
-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);
-
-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);
-    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.es.js';
+export { RouterStore, setCurrentNavigation, setUrlOnRehydrate } from './stores/RouterStore.es.js';
+export { usePageService } from './hooks/usePageService.es.js';