@tramvai/module-router 2.70.0 → 2.72.0

package/lib/modules/hooks/server/httpStatus.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const httpStatus = ({ responseManager }) => async ({ to }) => {
+    if (to === null || to === void 0 ? void 0 : to.config.httpStatus) {
+        responseManager.setStatus(to.config.httpStatus);
+    }
+};
+
+exports.httpStatus = httpStatus;

package/lib/modules/hooks/server/index.es.js

@@ -0,0 +1,17 @@
+import { RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { afterNavigateHooksToken } from '../../tokens.es.js';
+import { httpStatus } from './httpStatus.es.js';
+
+const serverHooks = [
+    {
+        provide: afterNavigateHooksToken,
+        multi: true,
+        // проставляет httpStatus если задан в текущем роуте
+        useFactory: httpStatus,
+        deps: {
+            responseManager: RESPONSE_MANAGER_TOKEN,
+        },
+    },
+];
+
+export { serverHooks };

package/lib/modules/hooks/server/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensCommon = require('@tramvai/tokens-common');
+var tokens = require('../../tokens.js');
+var httpStatus = require('./httpStatus.js');
+
+const serverHooks = [
+    {
+        provide: tokens.afterNavigateHooksToken,
+        multi: true,
+        // проставляет httpStatus если задан в текущем роуте
+        useFactory: httpStatus.httpStatus,
+        deps: {
+            responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
+        },
+    },
+];
+
+exports.serverHooks = serverHooks;

package/lib/modules/hooks/spa/index.browser.js

@@ -0,0 +1,70 @@
+import noop from '@tinkoff/utils/function/noop';
+import { DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens } from '@tramvai/core';
+import { ROUTER_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN } from '@tramvai/tokens-router';
+import { STORE_TOKEN, ACTION_REGISTRY_TOKEN, ACTION_PAGE_RUNNER_TOKEN } from '@tramvai/tokens-common';
+import { beforeNavigateHooksToken, afterNavigateHooksToken } from '../../tokens.browser.js';
+import { runCommandsSpa, runCommandsAfterSpa } from './runCommands.browser.js';
+import { runActionsFactory } from '../runActions.browser.js';
+
+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,
+            },
+        },
+    },
+];
+
+export { spaHooks };

package/lib/modules/hooks/spa/runCommands.browser.js

@@ -0,0 +1,12 @@
+const runCommandsSpa = ({ commandLineRunner, di, }) => {
+    return async () => {
+        await commandLineRunner.run('client', 'spa', [], di);
+    };
+};
+const runCommandsAfterSpa = ({ commandLineRunner, di, }) => {
+    return async () => {
+        await commandLineRunner.run('client', 'afterSpa', [], di);
+    };
+};
+
+export { runCommandsAfterSpa, runCommandsSpa };

package/lib/modules/no-spa.browser.js

@@ -0,0 +1,21 @@
+import { Module } from '@tramvai/core';
+import { NoSpaRouter } from '@tinkoff/router';
+import { providers } from './clientCommon.browser.js';
+import { generateForRoot } from './utils/forRoot.browser.js';
+import { routerClassToken } from './tokens.browser.js';
+
+var _a;
+const NoSpaRouterModule = /* @__PURE__ */ Module({
+    providers: [
+        ...providers,
+        {
+            provide: routerClassToken,
+            useValue: NoSpaRouter,
+        },
+    ],
+})((_a = class NoSpaRouterModule {
+    },
+    _a.forRoot = generateForRoot(_a),
+    _a));
+
+export { NoSpaRouterModule };

package/lib/modules/server.es.js

@@ -0,0 +1,59 @@
+import { __decorate } from 'tslib';
+import { Module, commandLineListTokens } from '@tramvai/core';
+import { Router } from '@tinkoff/router';
+import { REQUEST_MANAGER_TOKEN, STORE_TOKEN, ACTION_REGISTRY_TOKEN, ACTION_PAGE_RUNNER_TOKEN } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { providers } from './common.es.js';
+import { routerClassToken } from './tokens.es.js';
+import { serverGuards } from './guards/server/index.es.js';
+import { runActionsFactory } from './hooks/runActions.es.js';
+import { serverHooks } from './hooks/server/index.es.js';
+import { serverTokens } from './tokens/server/index.es.js';
+import { generateForRoot } from './utils/forRoot.es.js';
+
+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;
+
+export { NoSpaRouterModule, SpaRouterModule };

package/lib/modules/server.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var router = require('@tinkoff/router');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensRouter = require('@tramvai/tokens-router');
+var common = require('./common.js');
+var tokens = require('./tokens.js');
+var index = require('./guards/server/index.js');
+var runActions = require('./hooks/runActions.js');
+var index$1 = require('./hooks/server/index.js');
+var index$2 = require('./tokens/server/index.js');
+var forRoot = require('./utils/forRoot.js');
+
+var NoSpaRouterModule_1;
+exports.NoSpaRouterModule = NoSpaRouterModule_1 = class NoSpaRouterModule {
+};
+exports.NoSpaRouterModule.forRoot = forRoot.generateForRoot(NoSpaRouterModule_1);
+exports.NoSpaRouterModule = NoSpaRouterModule_1 = tslib.__decorate([
+    core.Module({
+        providers: [
+            ...common.providers,
+            ...index.serverGuards,
+            ...index$1.serverHooks,
+            ...index$2.serverTokens,
+            {
+                provide: tokens.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: runActions.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.SpaRouterModule = SpaRouterModule;

package/lib/modules/spa.browser.js

@@ -0,0 +1,23 @@
+import { Module } from '@tramvai/core';
+import { Router } from '@tinkoff/router';
+import { providers } from './clientCommon.browser.js';
+import { routerClassToken } from './tokens.browser.js';
+import { spaHooks } from './hooks/spa/index.browser.js';
+import { generateForRoot } from './utils/forRoot.browser.js';
+
+var _a;
+const SpaRouterModule = /* @__PURE__ */ Module({
+    providers: [
+        ...providers,
+        ...spaHooks,
+        {
+            provide: routerClassToken,
+            useValue: Router,
+        },
+    ],
+})((_a = class SpaRouterModule {
+    },
+    _a.forRoot = generateForRoot(_a),
+    _a));
+
+export { SpaRouterModule };

package/lib/modules/tokens/browser/index.browser.js

@@ -0,0 +1,5 @@
+import { prefetchProviders } from './prefetch.browser.js';
+
+const clientTokens = [...prefetchProviders];
+
+export { clientTokens };

package/lib/modules/tokens/browser/prefetch.browser.js

@@ -0,0 +1,112 @@
+import { createToken, provide } from '@tramvai/core';
+import { COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { LINK_PREFETCH_MANAGER_TOKEN, ROUTER_TOKEN, ROUTE_RESOLVE_TOKEN } from '@tramvai/tokens-router';
+import { addQuery } from '@tinkoff/url';
+import { resolveLazyComponent } from '@tramvai/react';
+import { isFileSystemPageComponent } from '@tramvai/experiments';
+import { routeTransformToken } from '../../tokens.browser.js';
+
+const PREFETCHED_LINKS_CACHE_TOKEN = createToken();
+const PREFETCHED_LINKS_QUEUE_TOKEN = createToken();
+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,
+        },
+    }),
+];
+
+export { prefetchProviders };

package/lib/modules/tokens/common/index.browser.js

@@ -0,0 +1,40 @@
+import { ROUTE_TRANSFORM_TOKEN, ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { EXTEND_RENDER } from '@tramvai/tokens-render';
+import { routeTransformToken } from '../../tokens.browser.js';
+import { routeTransform } from './routeTransform.browser.js';
+import { routeSetDefaults } from './routeSetDefaults.browser.js';
+import { routeNormalize } from './routeNormalize.browser.js';
+import { provideRouter } from './render.browser.js';
+
+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,
+        },
+    },
+];
+
+export { commonTokens };

package/lib/modules/tokens/common/index.es.js

@@ -0,0 +1,40 @@
+import { ROUTE_TRANSFORM_TOKEN, ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { EXTEND_RENDER } from '@tramvai/tokens-render';
+import { routeTransformToken } from '../../tokens.es.js';
+import { routeTransform } from './routeTransform.es.js';
+import { routeSetDefaults } from './routeSetDefaults.es.js';
+import { routeNormalize } from './routeNormalize.es.js';
+import { provideRouter } from './render.es.js';
+
+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,
+        },
+    },
+];
+
+export { commonTokens };

package/lib/modules/tokens/common/index.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensRouter = require('@tramvai/tokens-router');
+var tokensRender = require('@tramvai/tokens-render');
+var tokens = require('../../tokens.js');
+var routeTransform = require('./routeTransform.js');
+var routeSetDefaults = require('./routeSetDefaults.js');
+var routeNormalize = require('./routeNormalize.js');
+var render = require('./render.js');
+
+const commonTokens = [
+    {
+        provide: tokens.routeTransformToken,
+        useFactory: routeTransform.routeTransform,
+        deps: {
+            transformers: {
+                token: tokensRouter.ROUTE_TRANSFORM_TOKEN,
+                optional: true,
+            },
+        },
+    },
+    {
+        provide: tokensRouter.ROUTE_TRANSFORM_TOKEN,
+        multi: true,
+        useValue: routeSetDefaults.routeSetDefaults,
+    },
+    {
+        provide: tokensRouter.ROUTE_TRANSFORM_TOKEN,
+        multi: true,
+        useValue: routeNormalize.routeNormalize,
+    },
+    {
+        provide: tokensRender.EXTEND_RENDER,
+        multi: true,
+        useFactory: render.provideRouter,
+        deps: {
+            router: tokensRouter.ROUTER_TOKEN,
+        },
+    },
+];
+
+exports.commonTokens = commonTokens;

package/lib/modules/tokens/common/render.browser.js

@@ -0,0 +1,14 @@
+import { jsx } from 'react/jsx-runtime';
+import { Provider } from '@tinkoff/router';
+
+const provideRouter = ({ router }) => {
+    const serverState = {
+        currentRoute: router.getCurrentRoute(),
+        currentUrl: router.getCurrentUrl(),
+    };
+    return (render) => {
+        return (jsx(Provider, { router: router, serverState: serverState, children: render }));
+    };
+};
+
+export { provideRouter };

package/lib/modules/tokens/common/render.es.js

@@ -0,0 +1,14 @@
+import { jsx } from 'react/jsx-runtime';
+import { Provider } from '@tinkoff/router';
+
+const provideRouter = ({ router }) => {
+    const serverState = {
+        currentRoute: router.getCurrentRoute(),
+        currentUrl: router.getCurrentUrl(),
+    };
+    return (render) => {
+        return (jsx(Provider, { router: router, serverState: serverState, children: render }));
+    };
+};
+
+export { provideRouter };

package/lib/modules/tokens/common/render.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var router = require('@tinkoff/router');
+
+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 }));
+    };
+};
+
+exports.provideRouter = provideRouter;

package/lib/modules/tokens/common/routeNormalize.browser.js

@@ -0,0 +1,10 @@
+import replace from '@tinkoff/utils/string/replace';
+
+const routeNormalize = (route) => {
+    return {
+        ...route,
+        path: replace(/\/?$/, '/', route.path),
+    };
+};
+
+export { routeNormalize };

package/lib/modules/tokens/common/routeNormalize.es.js

@@ -0,0 +1,10 @@
+import replace from '@tinkoff/utils/string/replace';
+
+const routeNormalize = (route) => {
+    return {
+        ...route,
+        path: replace(/\/?$/, '/', route.path),
+    };
+};
+
+export { routeNormalize };

package/lib/modules/tokens/common/routeNormalize.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var replace = require('@tinkoff/utils/string/replace');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var replace__default = /*#__PURE__*/_interopDefaultLegacy(replace);
+
+const routeNormalize = (route) => {
+    return {
+        ...route,
+        path: replace__default["default"](/\/?$/, '/', route.path),
+    };
+};
+
+exports.routeNormalize = routeNormalize;

package/lib/modules/tokens/common/routeSetDefaults.browser.js

@@ -0,0 +1,13 @@
+const routeSetDefaults = (route) => {
+    const config = {
+        bundle: 'mainDefault',
+        pageComponent: 'pageDefault',
+        ...route.config,
+    };
+    return {
+        ...route,
+        config,
+    };
+};
+
+export { routeSetDefaults };

package/lib/modules/tokens/common/routeSetDefaults.es.js

@@ -0,0 +1,13 @@
+const routeSetDefaults = (route) => {
+    const config = {
+        bundle: 'mainDefault',
+        pageComponent: 'pageDefault',
+        ...route.config,
+    };
+    return {
+        ...route,
+        config,
+    };
+};
+
+export { routeSetDefaults };