@tramvai/module-child-app 4.18.5 → 4.19.0

package/lib/browser/child/singletonProviders.browser.js

@@ -1,6 +1,6 @@
 import noop from '@tinkoff/utils/function/noop';
 import { provide } from '@tramvai/core';
-import { commandLineListTokens, CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN, CHILD_APP_PAGE_SERVICE_TOKEN } from '@tramvai/tokens-child-app';
+import { commandLineListTokens, CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN, CHILD_APP_PAGE_SERVICE_TOKEN, CHILD_REQUIRED_CONTRACTS, CHILD_APP_COMMON_INITIAL_STATE_TOKEN } from '@tramvai/tokens-child-app';
 import { CONTEXT_TOKEN, ACTION_PAGE_RUNNER_TOKEN } from '@tramvai/tokens-common';
 import { Subscription } from '@tramvai/state';
 import { ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN } from '@tramvai/tokens-router';
@@ -60,10 +60,7 @@ const getChildProviders = (appDi) => {
             deps: {
                 actionRunner: ACTION_PAGE_RUNNER_TOKEN,
                 childAppPageService: CHILD_APP_PAGE_SERVICE_TOKEN,
-                spaMode: {
-                    token: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                    optional: true,
-                },
+                spaMode: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
             },
         }),
         provide({
@@ -81,12 +78,13 @@ const getChildProviders = (appDi) => {
             deps: {
                 actionRunner: ACTION_PAGE_RUNNER_TOKEN,
                 childAppPageService: CHILD_APP_PAGE_SERVICE_TOKEN,
-                spaMode: {
-                    token: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
-                    optional: true,
-                },
+                spaMode: ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
             },
         }),
+        provide({
+            provide: CHILD_REQUIRED_CONTRACTS,
+            useValue: [CHILD_APP_COMMON_INITIAL_STATE_TOKEN],
+        }),
     ];
 };
 

package/lib/browser/providers.browser.js

@@ -1,8 +1,9 @@
-import { Scope } from '@tinkoff/dippy';
+import { Scope, DI_TOKEN } from '@tinkoff/dippy';
 import { provide, commandLineListTokens } from '@tramvai/core';
-import { CHILD_APP_LOADER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMON_INITIAL_STATE_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMON_INITIAL_STATE_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS } from '@tramvai/tokens-child-app';
 import { LOGGER_TOKEN, STORE_TOKEN } from '@tramvai/tokens-common';
 import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
+import { ChildAppContractManager } from '../contracts/contractManager.browser.browser.js';
 import { BrowserLoader } from './loader.browser.js';
 import { PreloadManager } from './preload.browser.js';
 import { RenderManager } from './render.browser.js';
@@ -130,6 +131,20 @@ const browserProviders = [
             logger: LOGGER_TOKEN,
         },
     }),
+    provide({
+        provide: CHILD_APP_CONTRACT_MANAGER,
+        useFactory: (deps) => new ChildAppContractManager(deps),
+        deps: {
+            appDi: DI_TOKEN,
+            hostProvidedContracts: HOST_PROVIDED_CONTRACTS,
+        },
+    }),
+    provide({
+        provide: HOST_PROVIDED_CONTRACTS,
+        useValue: {
+            providedContracts: [CHILD_APP_COMMON_INITIAL_STATE_TOKEN],
+        },
+    }),
 ];
 
 export { browserProviders };

package/lib/contracts/contractManager.base.browser.js

@@ -0,0 +1,46 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import { optional } from '@tinkoff/dippy';
+import { CHILD_APP_INTERNAL_CONFIG_TOKEN, IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKEN, CHILD_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
+
+class BaseChildAppContractManager {
+    constructor({ hostProvidedContracts }) {
+        this.hostProvidedContracts = hostProvidedContracts;
+    }
+    registerChildContracts(childDi) {
+        var _a;
+        const childAppConfig = childDi.get(CHILD_APP_INTERNAL_CONFIG_TOKEN);
+        const childHasContractsSupport = childDi.get(optional(IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKEN));
+        const childRequiredContracts = flatten((_a = childDi.get(optional(CHILD_REQUIRED_CONTRACTS))) !== null && _a !== void 0 ? _a : []);
+        const childRequiredContractsKeys = childRequiredContracts.map((c) => c.toString());
+        const hostProvidedContracts = this.getHostProvidedContracts(childAppConfig.name);
+        // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+        // otherwise register only required for child app contracts
+        const hasContractsToRegistration = !childHasContractsSupport || childRequiredContracts.length > 0;
+        if (hasContractsToRegistration) {
+            for (const contract of hostProvidedContracts) {
+                const contractKey = contract.toString();
+                // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+                // otherwise match required and provided contracts by key
+                const isChildRequiredContract = !childHasContractsSupport || childRequiredContractsKeys.includes(contractKey);
+                if (isChildRequiredContract) {
+                    this.registerContract(childDi, contract);
+                }
+            }
+        }
+    }
+    getHostProvidedContracts(childAppName) {
+        const contracts = [];
+        // look over all provided by host contracts
+        for (const contract of this.hostProvidedContracts) {
+            // contracts without childAppName can be registered to any child app
+            // otherwise we need to match current and contract child app names
+            const contractAvailableForChild = !contract.childAppName || contract.childAppName === childAppName;
+            if (contractAvailableForChild) {
+                contracts.push(...contract.providedContracts);
+            }
+        }
+        return contracts;
+    }
+}
+
+export { BaseChildAppContractManager };

package/lib/contracts/contractManager.base.d.ts

@@ -0,0 +1,16 @@
+import type { ExtractDependencyType } from '@tinkoff/dippy';
+import { type Container } from '@tinkoff/dippy';
+import type { Contract, HOST_PROVIDED_CONTRACTS } from '@tramvai/tokens-child-app';
+import { type ChildAppContractManager as IChildAppContractManager } from '@tramvai/tokens-child-app';
+type HostProvidedContracts = ExtractDependencyType<typeof HOST_PROVIDED_CONTRACTS>;
+export declare abstract class BaseChildAppContractManager implements IChildAppContractManager {
+    private hostProvidedContracts;
+    constructor({ hostProvidedContracts }: {
+        hostProvidedContracts: HostProvidedContracts;
+    });
+    registerChildContracts(childDi: Container): void;
+    abstract registerContract(childDi: Container, contract: Contract): void;
+    private getHostProvidedContracts;
+}
+export {};
+//# sourceMappingURL=contractManager.base.d.ts.map

package/lib/contracts/contractManager.base.es.js

@@ -0,0 +1,46 @@
+import flatten from '@tinkoff/utils/array/flatten';
+import { optional } from '@tinkoff/dippy';
+import { CHILD_APP_INTERNAL_CONFIG_TOKEN, IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKEN, CHILD_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
+
+class BaseChildAppContractManager {
+    constructor({ hostProvidedContracts }) {
+        this.hostProvidedContracts = hostProvidedContracts;
+    }
+    registerChildContracts(childDi) {
+        var _a;
+        const childAppConfig = childDi.get(CHILD_APP_INTERNAL_CONFIG_TOKEN);
+        const childHasContractsSupport = childDi.get(optional(IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKEN));
+        const childRequiredContracts = flatten((_a = childDi.get(optional(CHILD_REQUIRED_CONTRACTS))) !== null && _a !== void 0 ? _a : []);
+        const childRequiredContractsKeys = childRequiredContracts.map((c) => c.toString());
+        const hostProvidedContracts = this.getHostProvidedContracts(childAppConfig.name);
+        // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+        // otherwise register only required for child app contracts
+        const hasContractsToRegistration = !childHasContractsSupport || childRequiredContracts.length > 0;
+        if (hasContractsToRegistration) {
+            for (const contract of hostProvidedContracts) {
+                const contractKey = contract.toString();
+                // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+                // otherwise match required and provided contracts by key
+                const isChildRequiredContract = !childHasContractsSupport || childRequiredContractsKeys.includes(contractKey);
+                if (isChildRequiredContract) {
+                    this.registerContract(childDi, contract);
+                }
+            }
+        }
+    }
+    getHostProvidedContracts(childAppName) {
+        const contracts = [];
+        // look over all provided by host contracts
+        for (const contract of this.hostProvidedContracts) {
+            // contracts without childAppName can be registered to any child app
+            // otherwise we need to match current and contract child app names
+            const contractAvailableForChild = !contract.childAppName || contract.childAppName === childAppName;
+            if (contractAvailableForChild) {
+                contracts.push(...contract.providedContracts);
+            }
+        }
+        return contracts;
+    }
+}
+
+export { BaseChildAppContractManager };

package/lib/contracts/contractManager.base.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var flatten = require('@tinkoff/utils/array/flatten');
+var dippy = require('@tinkoff/dippy');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+class BaseChildAppContractManager {
+    constructor({ hostProvidedContracts }) {
+        this.hostProvidedContracts = hostProvidedContracts;
+    }
+    registerChildContracts(childDi) {
+        var _a;
+        const childAppConfig = childDi.get(tokensChildApp.CHILD_APP_INTERNAL_CONFIG_TOKEN);
+        const childHasContractsSupport = childDi.get(dippy.optional(tokensChildApp.IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKEN));
+        const childRequiredContracts = flatten__default["default"]((_a = childDi.get(dippy.optional(tokensChildApp.CHILD_REQUIRED_CONTRACTS))) !== null && _a !== void 0 ? _a : []);
+        const childRequiredContractsKeys = childRequiredContracts.map((c) => c.toString());
+        const hostProvidedContracts = this.getHostProvidedContracts(childAppConfig.name);
+        // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+        // otherwise register only required for child app contracts
+        const hasContractsToRegistration = !childHasContractsSupport || childRequiredContracts.length > 0;
+        if (hasContractsToRegistration) {
+            for (const contract of hostProvidedContracts) {
+                const contractKey = contract.toString();
+                // if contracts unsupported, it is a legacy child app, and we need to register all possible contracts
+                // otherwise match required and provided contracts by key
+                const isChildRequiredContract = !childHasContractsSupport || childRequiredContractsKeys.includes(contractKey);
+                if (isChildRequiredContract) {
+                    this.registerContract(childDi, contract);
+                }
+            }
+        }
+    }
+    getHostProvidedContracts(childAppName) {
+        const contracts = [];
+        // look over all provided by host contracts
+        for (const contract of this.hostProvidedContracts) {
+            // contracts without childAppName can be registered to any child app
+            // otherwise we need to match current and contract child app names
+            const contractAvailableForChild = !contract.childAppName || contract.childAppName === childAppName;
+            if (contractAvailableForChild) {
+                contracts.push(...contract.providedContracts);
+            }
+        }
+        return contracts;
+    }
+}
+
+exports.BaseChildAppContractManager = BaseChildAppContractManager;

package/lib/contracts/contractManager.browser.browser.js

@@ -0,0 +1,22 @@
+import isNil from '@tinkoff/utils/is/nil';
+import { provide, optional } from '@tinkoff/dippy';
+import { BaseChildAppContractManager } from './contractManager.base.browser.js';
+
+class ChildAppContractManager extends BaseChildAppContractManager {
+    constructor({ appDi, hostProvidedContracts, }) {
+        super({ hostProvidedContracts });
+        this.appDi = appDi;
+    }
+    registerContract(childDi, contract) {
+        childDi.register(provide({
+            provide: contract,
+            useFactory: () => {
+                const value = this.appDi.get(optional(contract));
+                if (isNil(value)) ;
+                return value;
+            },
+        }));
+    }
+}
+
+export { ChildAppContractManager };

package/lib/contracts/contractManager.browser.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractDependencyType } from '@tinkoff/dippy';
+import { type Container } from '@tinkoff/dippy';
+import type { Contract, HOST_PROVIDED_CONTRACTS } from '@tramvai/tokens-child-app';
+import { BaseChildAppContractManager } from './contractManager.base';
+type HostProvidedContracts = ExtractDependencyType<typeof HOST_PROVIDED_CONTRACTS>;
+export declare class ChildAppContractManager extends BaseChildAppContractManager {
+    private appDi;
+    constructor({ appDi, hostProvidedContracts, }: {
+        appDi: Container;
+        hostProvidedContracts: HostProvidedContracts;
+    });
+    registerContract(childDi: Container, contract: Contract): void;
+}
+export {};
+//# sourceMappingURL=contractManager.browser.d.ts.map

package/lib/contracts/contractManager.server.d.ts

@@ -0,0 +1,24 @@
+import type { DI_TOKEN, ExtractDependencyType } from '@tinkoff/dippy';
+import { type Container } from '@tinkoff/dippy';
+import type { Contract, HOST_PROVIDED_CONTRACTS } from '@tramvai/tokens-child-app';
+import type { ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
+import { BaseChildAppContractManager } from './contractManager.base';
+declare module '@tramvai/tokens-common' {
+    interface AsyncLocalStorageState {
+        tramvaiRequestDi?: ExtractDependencyType<typeof DI_TOKEN>;
+    }
+}
+type HostProvidedContracts = ExtractDependencyType<typeof HOST_PROVIDED_CONTRACTS>;
+type AsyncLocalStorageType = ExtractDependencyType<typeof ASYNC_LOCAL_STORAGE_TOKEN>;
+export declare class ChildAppContractManager extends BaseChildAppContractManager {
+    private appDi;
+    private asyncLocalStorage;
+    constructor({ appDi, asyncLocalStorage, hostProvidedContracts, }: {
+        appDi: Container;
+        asyncLocalStorage: AsyncLocalStorageType;
+        hostProvidedContracts: HostProvidedContracts;
+    });
+    registerContract(childDi: Container, contract: Contract): void;
+}
+export {};
+//# sourceMappingURL=contractManager.server.d.ts.map

package/lib/contracts/contractManager.server.es.js

@@ -0,0 +1,25 @@
+import isNil from '@tinkoff/utils/is/nil';
+import { provide, optional } from '@tinkoff/dippy';
+import { BaseChildAppContractManager } from './contractManager.base.es.js';
+
+class ChildAppContractManager extends BaseChildAppContractManager {
+    constructor({ appDi, asyncLocalStorage, hostProvidedContracts, }) {
+        super({ hostProvidedContracts });
+        this.appDi = appDi;
+        this.asyncLocalStorage = asyncLocalStorage;
+    }
+    registerContract(childDi, contract) {
+        childDi.register(provide({
+            provide: contract,
+            useFactory: () => {
+                var _a, _b, _c;
+                const value = (_c = (_b = (_a = this.asyncLocalStorage.getStore()) === null || _a === void 0 ? void 0 : _a.tramvaiRequestDi) === null || _b === void 0 ? void 0 : _b.get(optional(contract))) !== null && _c !== void 0 ? _c : this.appDi.get(optional(contract));
+                if (isNil(value)) ;
+                // TODO: Request scoped contrace is resolved in Singleton scope - what should we do?
+                return value;
+            },
+        }));
+    }
+}
+
+export { ChildAppContractManager };

package/lib/contracts/contractManager.server.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isNil = require('@tinkoff/utils/is/nil');
+var dippy = require('@tinkoff/dippy');
+var contractManager_base = require('./contractManager.base.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
+
+class ChildAppContractManager extends contractManager_base.BaseChildAppContractManager {
+    constructor({ appDi, asyncLocalStorage, hostProvidedContracts, }) {
+        super({ hostProvidedContracts });
+        this.appDi = appDi;
+        this.asyncLocalStorage = asyncLocalStorage;
+    }
+    registerContract(childDi, contract) {
+        childDi.register(dippy.provide({
+            provide: contract,
+            useFactory: () => {
+                var _a, _b, _c;
+                const value = (_c = (_b = (_a = this.asyncLocalStorage.getStore()) === null || _a === void 0 ? void 0 : _a.tramvaiRequestDi) === null || _b === void 0 ? void 0 : _b.get(dippy.optional(contract))) !== null && _c !== void 0 ? _c : this.appDi.get(dippy.optional(contract));
+                if (isNil__default["default"](value)) ;
+                // TODO: Request scoped contrace is resolved in Singleton scope - what should we do?
+                return value;
+            },
+        }));
+    }
+}
+
+exports.ChildAppContractManager = ChildAppContractManager;

package/lib/server/providers.es.js

@@ -1,9 +1,9 @@
 import { combineValidators, isUrl, endsWith } from '@tinkoff/env-validators';
-import { Scope, optional } from '@tinkoff/dippy';
+import { Scope, optional, DI_TOKEN } from '@tinkoff/dippy';
 import { provide, commandLineListTokens } from '@tramvai/core';
-import { ENV_USED_TOKEN, LOGGER_TOKEN, CREATE_CACHE_TOKEN, ENV_MANAGER_TOKEN, STORE_TOKEN } from '@tramvai/tokens-common';
+import { ENV_USED_TOKEN, LOGGER_TOKEN, CREATE_CACHE_TOKEN, ENV_MANAGER_TOKEN, STORE_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
 import { RESOURCES_REGISTRY, RENDER_SLOTS, ResourceType, ResourceSlot, RENDER_FLOW_AFTER_TOKEN, REACT_SERVER_RENDER_MODE, EXTEND_RENDER } from '@tramvai/tokens-render';
-import { CHILD_APP_LOADER_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS } from '@tramvai/tokens-child-app';
 import { safeStringify } from '@tramvai/safe-strings';
 import { ServerLoader } from './loader.es.js';
 import { PreloadManager } from './preload.es.js';
@@ -12,6 +12,7 @@ import { setPreloaded } from '../shared/store.es.js';
 import { RenderManager } from './render.es.js';
 import { registerChildAppRenderSlots } from './render-slots.es.js';
 import { GLOBAL_CHILD_STATE } from '../shared/constants.es.js';
+import { ChildAppContractManager } from '../contracts/contractManager.server.es.js';
 
 const serverProviders = [
     provide({
@@ -138,6 +139,16 @@ const serverProviders = [
             renderManager: CHILD_APP_RENDER_MANAGER_TOKEN,
         },
     }),
+    provide({
+        provide: CHILD_APP_CONTRACT_MANAGER,
+        scope: Scope.SINGLETON,
+        useFactory: (deps) => new ChildAppContractManager(deps),
+        deps: {
+            appDi: DI_TOKEN,
+            asyncLocalStorage: ASYNC_LOCAL_STORAGE_TOKEN,
+            hostProvidedContracts: HOST_PROVIDED_CONTRACTS,
+        },
+    }),
 ];
 
 export { serverProviders };

package/lib/server/providers.js

@@ -16,6 +16,7 @@ var store = require('../shared/store.js');
 var render = require('./render.js');
 var renderSlots = require('./render-slots.js');
 var constants = require('../shared/constants.js');
+var contractManager_server = require('../contracts/contractManager.server.js');
 
 const serverProviders = [
     core.provide({
@@ -142,6 +143,16 @@ const serverProviders = [
             renderManager: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
         },
     }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_CONTRACT_MANAGER,
+        scope: dippy.Scope.SINGLETON,
+        useFactory: (deps) => new contractManager_server.ChildAppContractManager(deps),
+        deps: {
+            appDi: dippy.DI_TOKEN,
+            asyncLocalStorage: tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN,
+            hostProvidedContracts: tokensChildApp.HOST_PROVIDED_CONTRACTS,
+        },
+    }),
 ];
 
 exports.serverProviders = serverProviders;

package/lib/server/stateManager.es.js

@@ -33,12 +33,11 @@ class StateManager {
             this.state[key] = context.dehydrate().dispatcher;
         }
         catch (error) {
-            if (error.code !== 'E_STUB') {
-                this.log.error({
-                    event: 'get-state-failed',
-                    config,
-                });
-            }
+            this.log.error({
+                event: 'get-state-failed',
+                error,
+                config,
+            });
         }
     }
     getState() {

package/lib/server/stateManager.js

@@ -37,12 +37,11 @@ class StateManager {
             this.state[key] = context.dehydrate().dispatcher;
         }
         catch (error) {
-            if (error.code !== 'E_STUB') {
-                this.log.error({
-                    event: 'get-state-failed',
-                    config,
-                });
-            }
+            this.log.error({
+                event: 'get-state-failed',
+                error,
+                config,
+            });
         }
     }
     getState() {

package/lib/shared/child/extractorProviders.es.js

@@ -1,10 +1,11 @@
-import { provide } from '@tramvai/core';
+import { provide, Scope } from '@tramvai/core';
 import { CHILD_APP_INTERNAL_CHUNK_EXTRACTOR } from '@tramvai/tokens-child-app';
 import { ChunkExtractor } from '@loadable/server';
 
 const extractorProviders = (loadableStats) => [
     provide({
         provide: CHILD_APP_INTERNAL_CHUNK_EXTRACTOR,
+        scope: Scope.REQUEST,
         useFactory: () => {
             return new ChunkExtractor({ stats: loadableStats !== null && loadableStats !== void 0 ? loadableStats : {}, entrypoints: [] });
         },

package/lib/shared/child/extractorProviders.js

@@ -9,6 +9,7 @@ var server = require('@loadable/server');
 const extractorProviders = (loadableStats) => [
     core.provide({
         provide: tokensChildApp.CHILD_APP_INTERNAL_CHUNK_EXTRACTOR,
+        scope: core.Scope.REQUEST,
         useFactory: () => {
             return new server.ChunkExtractor({ stats: loadableStats !== null && loadableStats !== void 0 ? loadableStats : {}, entrypoints: [] });
         },

package/lib/shared/child/singletonProviders.browser.js

@@ -1,12 +1,16 @@
 import flatten from '@tinkoff/utils/array/flatten';
-import { provide, Scope } from '@tramvai/core';
+import { provide, Scope, APP_INFO_TOKEN, optional } from '@tramvai/core';
 import { ActionRegistry } from '@tramvai/module-common';
-import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { LOGGER_TOKEN, COMPONENT_REGISTRY_TOKEN, LIMIT_ACTION_GLOBAL_TIME_RUN, ACTION_CONDITIONALS, DEFERRED_ACTIONS_MAP_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, PUBSUB_TOKEN, PUBSUB_FACTORY_TOKEN, DISPATCHER_CONTEXT_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN, DISPATCHER_TOKEN, STORE_MIDDLEWARE, INITIAL_APP_STATE_TOKEN } from '@tramvai/tokens-common';
 import { RENDER_SLOTS } from '@tramvai/tokens-render';
-import { CHILD_APP_ACTIONS_REGISTRY_TOKEN, CHILD_APP_INTERNAL_ACTION_TOKEN } from '@tramvai/tokens-child-app';
+import { CHILD_APP_ACTIONS_REGISTRY_TOKEN, CHILD_APP_INTERNAL_ACTION_TOKEN, CHILD_REQUIRED_CONTRACTS, CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN, CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN, CHILD_APP_PAGE_SERVICE_TOKEN, CHILD_APP_INTERNAL_CONFIG_TOKEN, CHILD_APP_PAGE_COMPONENTS_TOKEN } from '@tramvai/tokens-child-app';
+import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN } from '@tramvai/tokens-router';
+import { ChildDispatcherContext } from '@tramvai/state';
 import { getChildProviders as getChildProviders$1 } from '../../browser/child/singletonProviders.browser.js';
+import { extractorProviders } from './extractorProviders.browser.browser.js';
+import { ChildAppPageService } from '../pageService.browser.js';
 
-const getChildProviders = (appDi) => {
+const getChildProviders = (appDi, loadableStats) => {
     const logger = appDi.get(LOGGER_TOKEN);
     return [
         provide({
@@ -30,7 +34,78 @@ const getChildProviders = (appDi) => {
                 actionsList: CHILD_APP_INTERNAL_ACTION_TOKEN,
             },
         }),
+        provide({
+            provide: CHILD_REQUIRED_CONTRACTS,
+            useValue: [
+                ROUTER_TOKEN,
+                COMPONENT_REGISTRY_TOKEN,
+                PAGE_SERVICE_TOKEN,
+                LINK_PREFETCH_MANAGER_TOKEN,
+                ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN,
+                LIMIT_ACTION_GLOBAL_TIME_RUN,
+            ],
+        }),
+        // for backward compatibility, when:
+        // - host app is modern (with contracts)
+        // - child app is legacy (<= v3.x.x, without contracts)
+        // - DI is isolated
+        // in legacy tramvai versions, this tokens is not borrowed in CommonChildAppModule
+        provide({
+            provide: CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
+            multi: true,
+            useValue: [
+                APP_INFO_TOKEN,
+                ACTION_CONDITIONALS,
+                DEFERRED_ACTIONS_MAP_TOKEN,
+                EXECUTION_CONTEXT_MANAGER_TOKEN,
+                COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                PUBSUB_TOKEN,
+                PUBSUB_FACTORY_TOKEN,
+            ],
+        }),
         ...getChildProviders$1(appDi),
+        ...extractorProviders(),
+        provide({
+            provide: DISPATCHER_CONTEXT_TOKEN,
+            scope: Scope.REQUEST,
+            useFactory: ({ dispatcher, middlewares, initialState, parentAllowedStores }) => {
+                var _a, _b, _c, _d;
+                const parentDispatcherContext = (_d = (_c = (_b = (_a = appDi
+                    .get(optional(ASYNC_LOCAL_STORAGE_TOKEN))) === null || _a === void 0 ? void 0 : _a.getStore()) === null || _b === void 0 ? void 0 : _b.tramvaiRequestDi) === null || _c === void 0 ? void 0 : _c.get(DISPATCHER_CONTEXT_TOKEN)) !== null && _d !== void 0 ? _d : appDi.get(DISPATCHER_CONTEXT_TOKEN);
+                return new ChildDispatcherContext({
+                    dispatcher,
+                    // context will be set later by the CONTEXT_TOKEN
+                    context: {},
+                    initialState: initialState !== null && initialState !== void 0 ? initialState : { stores: [] },
+                    middlewares: flatten(middlewares || []),
+                    parentDispatcherContext,
+                    parentAllowedStores: flatten(parentAllowedStores || []),
+                });
+            },
+            deps: {
+                dispatcher: DISPATCHER_TOKEN,
+                middlewares: { token: STORE_MIDDLEWARE, optional: true },
+                initialState: { token: INITIAL_APP_STATE_TOKEN, optional: true },
+                parentAllowedStores: {
+                    token: CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN,
+                    optional: true,
+                },
+            },
+        }),
+        provide({
+            provide: CHILD_APP_PAGE_SERVICE_TOKEN,
+            scope: Scope.REQUEST,
+            useFactory: (deps) => {
+                return new ChildAppPageService(deps);
+            },
+            deps: {
+                actionsRegistry: CHILD_APP_ACTIONS_REGISTRY_TOKEN,
+                config: CHILD_APP_INTERNAL_CONFIG_TOKEN,
+                componentRegistry: COMPONENT_REGISTRY_TOKEN,
+                pageService: PAGE_SERVICE_TOKEN,
+                pageComponents: optional(CHILD_APP_PAGE_COMPONENTS_TOKEN),
+            },
+        }),
     ];
 };
 

package/lib/shared/child/singletonProviders.d.ts

@@ -1,4 +1,5 @@
 import type { Container } from '@tinkoff/dippy';
 import type { Provider } from '@tramvai/core';
-export declare const getChildProviders: (appDi: Container) => Provider[];
+import type { LoadableStats } from '../webpack/moduleFederation';
+export declare const getChildProviders: (appDi: Container, loadableStats: LoadableStats) => Provider[];
 //# sourceMappingURL=singletonProviders.d.ts.map