@tramvai/module-router 2.70.1 → 2.72.0

package/lib/modules/child-app.browser.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { Module, provide } from '@tramvai/core';
+import { ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { EXTEND_RENDER } from '@tramvai/tokens-render';
+import { CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN } from '@tramvai/tokens-child-app';
+import { provideRouter } from './tokens/common/render.browser.js';
+import { RouterStore } from '../stores/RouterStore.browser.js';
+
+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);
+
+export { RouterChildAppModule };

package/lib/modules/child-app.es.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { Module, provide } from '@tramvai/core';
+import { ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { EXTEND_RENDER } from '@tramvai/tokens-render';
+import { CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN } from '@tramvai/tokens-child-app';
+import { provideRouter } from './tokens/common/render.es.js';
+import { RouterStore } from '../stores/RouterStore.es.js';
+
+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);
+
+export { RouterChildAppModule };

package/lib/modules/child-app.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensRouter = require('@tramvai/tokens-router');
+var tokensRender = require('@tramvai/tokens-render');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var render = require('./tokens/common/render.js');
+var RouterStore = require('../stores/RouterStore.js');
+
+exports.RouterChildAppModule = class RouterChildAppModule {
+};
+exports.RouterChildAppModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensRender.EXTEND_RENDER,
+                multi: true,
+                useFactory: render.provideRouter,
+                deps: {
+                    router: tokensRouter.ROUTER_TOKEN,
+                },
+            }),
+            {
+                provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN,
+                multi: true,
+                useValue: RouterStore.RouterStore,
+            },
+        ],
+    })
+], exports.RouterChildAppModule);

package/lib/modules/clientCommon.browser.js

@@ -0,0 +1,70 @@
+import { provide, commandLineListTokens } from '@tramvai/core';
+import { STORE_TOKEN, ENV_MANAGER_TOKEN, ACTION_REGISTRY_TOKEN, ACTION_PAGE_RUNNER_TOKEN } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { RouterStore, setUrlOnRehydrate } from '../stores/RouterStore.browser.js';
+import { providers as providers$1 } from './common.browser.js';
+import { clientTokens } from './tokens/browser/index.browser.js';
+import { runActionsFactory } from './hooks/runActions.browser.js';
+
+const providers = [
+    ...clientTokens,
+    ...providers$1,
+    provide({
+        provide: commandLineListTokens.customerStart,
+        multi: true,
+        useFactory: ({ router, store, envManager }) => {
+            return async function routerInit() {
+                // регидрация для CSR заглушки без серверного состояния,
+                // что бы запустить хуки beforeResolve и change
+                if (envManager.get('TRAMVAI_FORCE_CLIENT_SIDE_RENDERING') === 'true') {
+                    return router.rehydrate({});
+                }
+                const currentRoute = store.getState(RouterStore).currentRoute;
+                return router.rehydrate({
+                    to: currentRoute,
+                });
+            };
+        },
+        deps: {
+            router: ROUTER_TOKEN,
+            store: STORE_TOKEN,
+            envManager: ENV_MANAGER_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) => {
+            return runActionsFactory(deps);
+        },
+        deps: {
+            store: STORE_TOKEN,
+            router: ROUTER_TOKEN,
+            actionRegistry: ACTION_REGISTRY_TOKEN,
+            actionPageRunner: ACTION_PAGE_RUNNER_TOKEN,
+        },
+    }),
+];
+
+export { providers };

package/lib/modules/common.browser.js

@@ -0,0 +1,137 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import { commandLineListTokens, provide } from '@tramvai/core';
+import { setLogger } from '@tinkoff/router';
+import { LOGGER_TOKEN, COMPONENT_REGISTRY_TOKEN, COMBINE_REDUCERS } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN, ROUTES_TOKEN, ROUTE_RESOLVE_TOKEN, ROUTER_GUARD_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN, PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
+import { routerClassToken, additionalRouterParameters, routeTransformToken, onChangeHooksToken, beforeResolveHooksToken, beforeNavigateHooksToken, afterNavigateHooksToken, beforeUpdateCurrentHooksToken, afterUpdateCurrentHooksToken } from './tokens.browser.js';
+import { RouterStore } from '../stores/RouterStore.browser.js';
+import { commonGuards } from './guards/common/index.browser.js';
+import { commonHooks } from './hooks/common/index.browser.js';
+import { commonTokens } from './tokens/common/index.browser.js';
+import { PageService } from '../services/page.browser.js';
+import { providers as providers$1 } from './fileSystemPages.browser.js';
+
+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,
+    },
+];
+
+export { providers };

package/lib/modules/common.es.js

@@ -0,0 +1,137 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import { commandLineListTokens, provide } from '@tramvai/core';
+import { setLogger } from '@tinkoff/router';
+import { LOGGER_TOKEN, COMPONENT_REGISTRY_TOKEN, COMBINE_REDUCERS } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN, ROUTES_TOKEN, ROUTE_RESOLVE_TOKEN, ROUTER_GUARD_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN, PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
+import { routerClassToken, additionalRouterParameters, routeTransformToken, onChangeHooksToken, beforeResolveHooksToken, beforeNavigateHooksToken, afterNavigateHooksToken, beforeUpdateCurrentHooksToken, afterUpdateCurrentHooksToken } from './tokens.es.js';
+import { RouterStore } from '../stores/RouterStore.es.js';
+import { commonGuards } from './guards/common/index.es.js';
+import { commonHooks } from './hooks/common/index.es.js';
+import { commonTokens } from './tokens/common/index.es.js';
+import { PageService } from '../services/page.es.js';
+import { providers as providers$1 } from './fileSystemPages.es.js';
+
+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,
+    },
+];
+
+export { providers };

package/lib/modules/common.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var flatten = require('@tinkoff/utils/array/flatten');
+var core = require('@tramvai/core');
+var router = require('@tinkoff/router');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensRouter = require('@tramvai/tokens-router');
+var tokens = require('./tokens.js');
+var RouterStore = require('../stores/RouterStore.js');
+var index = require('./guards/common/index.js');
+var index$1 = require('./hooks/common/index.js');
+var index$2 = require('./tokens/common/index.js');
+var page = require('../services/page.js');
+var fileSystemPages = require('./fileSystemPages.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+const providers = [
+    ...index.commonGuards,
+    ...index$1.commonHooks,
+    ...index$2.commonTokens,
+    ...fileSystemPages.providers,
+    {
+        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: tokens.routerClassToken,
+            additionalParameters: {
+                token: tokens.additionalRouterParameters,
+                optional: true,
+            },
+            routes: {
+                token: tokensRouter.ROUTES_TOKEN,
+                optional: true,
+            },
+            routeTransform: tokens.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: tokens.onChangeHooksToken,
+                optional: true,
+            },
+            beforeResolve: {
+                token: tokens.beforeResolveHooksToken,
+                optional: true,
+            },
+            beforeNavigate: {
+                token: tokens.beforeNavigateHooksToken,
+                optional: true,
+            },
+            afterNavigate: {
+                token: tokens.afterNavigateHooksToken,
+                optional: true,
+            },
+            beforeUpdateCurrent: {
+                token: tokens.beforeUpdateCurrentHooksToken,
+                optional: true,
+            },
+            afterUpdateCurrent: {
+                token: tokens.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: page.PageService,
+        deps: {
+            router: tokensRouter.ROUTER_TOKEN,
+            componentRegistry: tokensCommon.COMPONENT_REGISTRY_TOKEN,
+        },
+    }),
+    {
+        provide: tokensCommon.COMBINE_REDUCERS,
+        multi: true,
+        useValue: RouterStore.RouterStore,
+    },
+];
+
+exports.providers = providers;

package/lib/modules/fileSystemPages.browser.js

@@ -0,0 +1,27 @@
+import { provide } from '@tramvai/core';
+import { ROUTES_TOKEN } from '@tramvai/tokens-router';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { fileSystemPagesEnabled, getStaticFileSystemPages, fileSystemPageToRoute } from '@tramvai/experiments';
+
+const providers = [
+    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);
+
+export { providers };

package/lib/modules/fileSystemPages.es.js

@@ -0,0 +1,27 @@
+import { provide } from '@tramvai/core';
+import { ROUTES_TOKEN } from '@tramvai/tokens-router';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { fileSystemPagesEnabled, getStaticFileSystemPages, fileSystemPageToRoute } from '@tramvai/experiments';
+
+const providers = [
+    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);
+
+export { providers };

package/lib/modules/fileSystemPages.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensRouter = require('@tramvai/tokens-router');
+var tokensCommon = require('@tramvai/tokens-common');
+var experiments = require('@tramvai/experiments');
+
+const providers = [
+    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);
+
+exports.providers = providers;