@tramvai/module-child-app 5.49.1 → 6.59.0

package/lib/server/render-slots.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var path = require('path');
-var semver = require('semver');
 var flatten = require('@tinkoff/utils/array/flatten');
 var url = require('@tinkoff/url');
 var tokensChildApp = require('@tramvai/tokens-child-app');
 var tokensRender = require('@tramvai/tokens-render');
 var moduleFederation = require('../shared/webpack/moduleFederation.js');
+var utils = require('./module-federation/utils.js');
+var bestLoadedSharedModules = require('./module-federation/best-loaded-shared-modules.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -26,14 +27,16 @@ const deferScriptAttrs = {
 // and Child App initialization logic executed after that, we need to get script loading status
 const entryAttrs = {
     onload: `this.setAttribute('loaded', 'true')`,
-    onerror: `this.setAttribute('loaded', 'false')`,
+    onerror: `this.setAttribute('loaded', 'error')`,
 };
 // for cases when preloaded chunk loading is failed before webpack add this script loading handlers,
 // we need to remove script and webpack will try to load it itself https://github.com/webpack/webpack/issues/14874
 const chunkAttrs = {
     onerror: `this.remove()`,
 };
-const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, preloadManager, loader, renderMode, resourcesRegistry, }) => async () => {
+const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, preloadManager, loader, renderMode, resourcesRegistry, }) => 
+// eslint-disable-next-line max-statements
+async () => {
     const log = logger('child-app:render:slots');
     const result = [];
     // defer scripts is not suitable for React streaming, we need to ability to run them as early as possible
@@ -72,36 +75,25 @@ const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, pre
     };
     const preloadedList = new Set(preloadManager.getPreloadedList());
     const sharedScope = moduleFederation.getSharedScope();
-    const mapSharedToChildApp = new Map();
-    // sharedScope will contain all of the shared chunks that were added
-    // while server is running
-    // but on the page we can use only shared chunks that either provided by the root-app
-    // or one of loaded child-app
-    // so gather all of the available shared modules, check the ones that are available in the currently
-    // preloaded child-apps and figure out the best single version of the dep
-    for (const shareKey in sharedScope) {
-        for (const version in sharedScope[shareKey]) {
-            const dep = sharedScope[shareKey][version];
-            const last = mapSharedToChildApp.get(shareKey);
-            const { eager, from } = dep;
-            const [type, name] = from.split(':');
-            if (!last ||
-                // module federation will pick the highest available version
-                // https://github.com/webpack/webpack/blob/b67626c7b4ffed8737d195b27c8cea1e68d58134/lib/sharing/ConsumeSharedRuntimeModule.js#L144
-                semver.gt(version, last.version) ||
-                // if versions are equal then module federation will pick
-                // the dep with eager prop (it's set in root-app) of with the child-app with highest name in alphabetical order
-                (semver.eq(version, last.version) && (eager !== last.eager ? eager : name > last.name))) {
-                mapSharedToChildApp.set(shareKey, { version, type, name, eager });
-            }
-        }
-    }
+    const preloadedConfigs = Array.from(preloadedList)
+        .map((requestConfig) => {
+        return resolveFullConfig(requestConfig);
+    })
+        .filter(Boolean);
+    // flat list of all shared items initialized in shared scope
+    const sharedScopeItems = utils.getFlatSharedScopeItemsList(sharedScope);
+    // flat list of all preloaded Child Apps shared modules
+    const sharedModules = utils.getFlatSharedModulesList({
+        preloadedConfigs,
+        loader: loader,
+    });
+    // optimal shared dependencies for preloaded Child Apps
+    const bestSharedModules = bestLoadedSharedModules.resolveBestLoadedSharedModules({
+        sharedModules,
+        sharedScopeItems,
+    });
     // eslint-disable-next-line max-statements
-    preloadedList.forEach((requestConfig) => {
-        const config = resolveFullConfig(requestConfig);
-        if (!config) {
-            return;
-        }
+    preloadedConfigs.forEach((config) => {
         const stats = 'getStats' in loader ? loader.getStats(config) : undefined;
         const di = diManager.getChildDi(config);
         const loadableAssets = di?.get(tokensChildApp.CHILD_APP_INTERNAL_CHUNK_EXTRACTOR)?.getMainAssets();
@@ -131,21 +123,6 @@ const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, pre
                 for (const file of files) {
                     addChunk(url.resolve(config.client.baseUrl, file));
                 }
-                for (const sharedModule of federatedModule.sharedModules) {
-                    const { shareKey } = sharedModule.provides?.[0] ?? {};
-                    const { chunks } = sharedModule;
-                    const bestShared = mapSharedToChildApp.get(shareKey);
-                    if (!bestShared?.eager && bestShared?.name === config.name) {
-                        for (const chunk of chunks) {
-                            addChunk(url.resolve(config.client.baseUrl, chunk));
-                        }
-                        // in stats.json federated stats could contain 2 sets of chunks for shared modules
-                        // there usual one and fallback. For shared module there could be used any of this
-                        // and the other one will be useless. So delete entry from map after its usage in order
-                        // to add only single set of chunks for the same shared dep
-                        mapSharedToChildApp.delete(shareKey);
-                    }
-                }
             }
         }
         if (!di) {
@@ -161,13 +138,48 @@ const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, pre
             log.error({
                 event: 'get-slots-failed',
                 childApp: {
-                    name: requestConfig.name,
-                    version: requestConfig.version,
-                    tag: requestConfig.tag,
+                    name: config.name,
+                    version: config.version,
+                    tag: config.tag,
                 },
             });
         }
     });
+    // shared chunks deduplication
+    const addedSharedChunks = new Set();
+    // preloaded chunks we need to pass to client
+    const serializableSharedModules = [];
+    bestSharedModules.forEach(({ shareKey, version, chunks, childAppName, childAppVersion }) => {
+        const childAppConfig = preloadedConfigs.find((config) => {
+            return config.name === childAppName && config.version === childAppVersion;
+        });
+        // if it is application shared dependency, we don't have any extra chunks
+        if (childAppConfig && chunks) {
+            for (const chunk of chunks) {
+                if (!addedSharedChunks.has(chunk)) {
+                    addedSharedChunks.add(chunk);
+                    addChunk(url.resolve(childAppConfig.client.baseUrl, chunk));
+                    const containerName = `child-app__${childAppConfig.client.entry}`;
+                    serializableSharedModules.push({
+                        containerName,
+                        shareKey,
+                        version,
+                        childAppName: childAppName,
+                        childAppVersion: childAppVersion,
+                    });
+                }
+            }
+        }
+    });
+    result.push({
+        type: tokensRender.ResourceType.inlineScript,
+        slot: tokensRender.ResourceSlot.HEAD_POLYFILLS,
+        payload: `window.__webpack_share_preloaded__ = [
+${serializableSharedModules.map((m) => {
+            return `${JSON.stringify(m)}`;
+        })}
+];`,
+    });
     result.map((item) => resourcesRegistry.register(item));
 };
 

package/lib/server/render.d.ts

@@ -1,5 +1,6 @@
 import type { Container } from '@tinkoff/dippy';
-import type { ChildAppDiManager, ChildAppPreloadManager, ChildAppRenderManager, ChildAppRequestConfig, CHILD_APP_RESOLVE_CONFIG_TOKEN } from '@tramvai/tokens-child-app';
+import { SyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
+import type { ChildAppDiManager, ChildAppPreloadManager, ChildAppRenderManager, ChildAppRequestConfig, CHILD_APP_RESOLVE_CONFIG_TOKEN, ChildAppConfigArgs } from '@tramvai/tokens-child-app';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 export declare class RenderManager implements ChildAppRenderManager {
     private readonly preloadManager;
@@ -7,7 +8,13 @@ export declare class RenderManager implements ChildAppRenderManager {
     private readonly resolveFullConfig;
     private readonly log;
     private readonly hasRenderedSet;
-    constructor({ logger, preloadManager, diManager, resolveFullConfig, }: {
+    private hookFactory;
+    hooks: {
+        mounted: SyncTapableHookInstance<ChildAppConfigArgs>;
+        mountFailed: SyncTapableHookInstance<ChildAppConfigArgs>;
+    };
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, hookFactory, }: {
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
         logger: typeof LOGGER_TOKEN;
         preloadManager: ChildAppPreloadManager;
         diManager: ChildAppDiManager;

package/lib/server/render.es.js

@@ -1,6 +1,17 @@
 class RenderManager {
-    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
-        this.hasRenderedSet = new Set();
+    preloadManager;
+    diManager;
+    resolveFullConfig;
+    log;
+    hasRenderedSet = new Set();
+    hookFactory;
+    hooks;
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, hookFactory, }) {
+        this.hookFactory = hookFactory;
+        this.hooks = {
+            mounted: this.hookFactory.createSync('childAppMounted'),
+            mountFailed: this.hookFactory.createSync('childAppMountFailed'),
+        };
         this.log = logger('child-app:render');
         this.preloadManager = preloadManager;
         this.diManager = diManager;

package/lib/server/render.js

@@ -3,8 +3,19 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class RenderManager {
-    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
-        this.hasRenderedSet = new Set();
+    preloadManager;
+    diManager;
+    resolveFullConfig;
+    log;
+    hasRenderedSet = new Set();
+    hookFactory;
+    hooks;
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, hookFactory, }) {
+        this.hookFactory = hookFactory;
+        this.hooks = {
+            mounted: this.hookFactory.createSync('childAppMounted'),
+            mountFailed: this.hookFactory.createSync('childAppMountFailed'),
+        };
         this.log = logger('child-app:render');
         this.preloadManager = preloadManager;
         this.diManager = diManager;

package/lib/server/stateManager.es.js

@@ -17,8 +17,10 @@ const executeRootStateSubscriptions = ({ store, diManager, }) => {
     };
 };
 class StateManager {
+    log;
+    diManager;
+    state = Object.create(null);
     constructor({ logger, diManager, }) {
-        this.state = Object.create(null);
         this.log = logger('child-app:state-manager');
         this.diManager = diManager;
     }

package/lib/server/stateManager.js

@@ -21,8 +21,10 @@ const executeRootStateSubscriptions = ({ store, diManager, }) => {
     };
 };
 class StateManager {
+    log;
+    diManager;
+    state = Object.create(null);
     constructor({ logger, diManager, }) {
-        this.state = Object.create(null);
         this.log = logger('child-app:state-manager');
         this.diManager = diManager;
     }

package/lib/shared/command.browser.js

@@ -3,6 +3,10 @@ import { COMMAND_LINE_RUNNER_TOKEN, provide } from '@tramvai/core';
 import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
 
 class CommandLineRunner {
+    log;
+    rootCommandLineRunner;
+    diManager;
+    commandLineExecutionContext;
     constructor({ logger, rootCommandLineRunner, diManager, commandLineExecutionContext, }) {
         this.log = logger('child-app:command-line-runner');
         this.rootCommandLineRunner = rootCommandLineRunner;

package/lib/shared/command.es.js

@@ -3,6 +3,10 @@ import { COMMAND_LINE_RUNNER_TOKEN, provide } from '@tramvai/core';
 import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
 
 class CommandLineRunner {
+    log;
+    rootCommandLineRunner;
+    diManager;
+    commandLineExecutionContext;
     constructor({ logger, rootCommandLineRunner, diManager, commandLineExecutionContext, }) {
         this.log = logger('child-app:command-line-runner');
         this.rootCommandLineRunner = rootCommandLineRunner;

package/lib/shared/command.js

@@ -7,6 +7,10 @@ var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
 
 class CommandLineRunner {
+    log;
+    rootCommandLineRunner;
+    diManager;
+    commandLineExecutionContext;
     constructor({ logger, rootCommandLineRunner, diManager, commandLineExecutionContext, }) {
         this.log = logger('child-app:command-line-runner');
         this.rootCommandLineRunner = rootCommandLineRunner;

package/lib/shared/di.browser.js

@@ -2,8 +2,12 @@ import { ChildContainer } from '@tinkoff/dippy';
 import { shouldIsolateDi } from './isolatedDi.browser.js';
 
 class DiManager {
+    appDi;
+    loader;
+    singletonDiManager;
+    rootDiAccessMode;
+    cache = new Map();
     constructor({ appDi, loader, singletonDiManager, rootDiAccessMode, }) {
-        this.cache = new Map();
         this.appDi = appDi;
         this.loader = loader;
         this.singletonDiManager = singletonDiManager;

package/lib/shared/di.es.js

@@ -2,8 +2,12 @@ import { ChildContainer } from '@tinkoff/dippy';
 import { shouldIsolateDi } from './isolatedDi.es.js';
 
 class DiManager {
+    appDi;
+    loader;
+    singletonDiManager;
+    rootDiAccessMode;
+    cache = new Map();
     constructor({ appDi, loader, singletonDiManager, rootDiAccessMode, }) {
-        this.cache = new Map();
         this.appDi = appDi;
         this.loader = loader;
         this.singletonDiManager = singletonDiManager;

package/lib/shared/di.js

@@ -6,8 +6,12 @@ var dippy = require('@tinkoff/dippy');
 var isolatedDi = require('./isolatedDi.js');
 
 class DiManager {
+    appDi;
+    loader;
+    singletonDiManager;
+    rootDiAccessMode;
+    cache = new Map();
     constructor({ appDi, loader, singletonDiManager, rootDiAccessMode, }) {
-        this.cache = new Map();
         this.appDi = appDi;
         this.loader = loader;
         this.singletonDiManager = singletonDiManager;

package/lib/shared/pageService.browser.js

@@ -2,6 +2,10 @@ import isArray from '@tinkoff/utils/is/array';
 import { resolveLazyComponent } from '@tramvai/react';
 
 class ChildAppPageService {
+    actionsRegistry;
+    config;
+    componentRegistry;
+    pageService;
     constructor({ actionsRegistry, config, componentRegistry, pageService, pageComponents, }) {
         this.actionsRegistry = actionsRegistry;
         this.config = config;
@@ -11,9 +15,10 @@ class ChildAppPageService {
         (pageComponents || []).forEach((record) => {
             Object.keys(record).forEach((pageComponentName) => {
                 const pageComponent = record[pageComponentName];
-                if (!this.componentRegistry.get(pageComponentName, componentsGroupName)) {
-                    this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
-                }
+                // to prevent memory leaks, always register Child App components,
+                // because if Child App server JS is loaded again after eviction from server loader cache,
+                // we want to load new instance of components and actions and clear memory references to old server JS
+                this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
             });
         });
     }

package/lib/shared/pageService.es.js

@@ -2,6 +2,10 @@ import isArray from '@tinkoff/utils/is/array';
 import { resolveLazyComponent } from '@tramvai/react';
 
 class ChildAppPageService {
+    actionsRegistry;
+    config;
+    componentRegistry;
+    pageService;
     constructor({ actionsRegistry, config, componentRegistry, pageService, pageComponents, }) {
         this.actionsRegistry = actionsRegistry;
         this.config = config;
@@ -11,9 +15,10 @@ class ChildAppPageService {
         (pageComponents || []).forEach((record) => {
             Object.keys(record).forEach((pageComponentName) => {
                 const pageComponent = record[pageComponentName];
-                if (!this.componentRegistry.get(pageComponentName, componentsGroupName)) {
-                    this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
-                }
+                // to prevent memory leaks, always register Child App components,
+                // because if Child App server JS is loaded again after eviction from server loader cache,
+                // we want to load new instance of components and actions and clear memory references to old server JS
+                this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
             });
         });
     }

package/lib/shared/pageService.js

@@ -10,6 +10,10 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var isArray__default = /*#__PURE__*/_interopDefaultLegacy(isArray);
 
 class ChildAppPageService {
+    actionsRegistry;
+    config;
+    componentRegistry;
+    pageService;
     constructor({ actionsRegistry, config, componentRegistry, pageService, pageComponents, }) {
         this.actionsRegistry = actionsRegistry;
         this.config = config;
@@ -19,9 +23,10 @@ class ChildAppPageService {
         (pageComponents || []).forEach((record) => {
             Object.keys(record).forEach((pageComponentName) => {
                 const pageComponent = record[pageComponentName];
-                if (!this.componentRegistry.get(pageComponentName, componentsGroupName)) {
-                    this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
-                }
+                // to prevent memory leaks, always register Child App components,
+                // because if Child App server JS is loaded again after eviction from server loader cache,
+                // we want to load new instance of components and actions and clear memory references to old server JS
+                this.componentRegistry.add(pageComponentName, pageComponent, componentsGroupName);
             });
         });
     }

package/lib/shared/providers.browser.js

@@ -1,6 +1,6 @@
 import { Scope, DI_TOKEN, optional } from '@tinkoff/dippy';
-import { provide, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
-import { CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLUTION_CONFIGS_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RESOLVE_BASE_URL_TOKEN, CHILD_APP_SINGLETON_DI_MANAGER_TOKEN, CHILD_APP_LOADER_TOKEN, CHILD_APP_ROOT_DI_ACCESS_MODE_TOKEN, CHILD_APP_CONTRACT_MANAGER, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, HOST_PROVIDED_CONTRACTS, CHILD_APP_ERROR_BOUNDARY_TOKEN } from '@tramvai/tokens-child-app';
+import { provide, commandLineListTokens, TAPABLE_HOOK_FACTORY_TOKEN, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
+import { CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_CONFIG_RESOLUTION_PLUGIN, CHILD_APP_RESOLUTION_CONFIGS_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RESOLVE_BASE_URL_TOKEN, CHILD_APP_SINGLETON_DI_MANAGER_TOKEN, CHILD_APP_LOADER_TOKEN, CHILD_APP_ROOT_DI_ACCESS_MODE_TOKEN, CHILD_APP_CONTRACT_MANAGER, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, HOST_PROVIDED_CONTRACTS, CHILD_APP_ERROR_BOUNDARY_TOKEN } from '@tramvai/tokens-child-app';
 import { COMBINE_REDUCERS, LOGGER_TOKEN, ENV_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, REGISTER_CLEAR_CACHE_TOKEN, CLEAR_CACHE_TOKEN, ENV_USED_TOKEN, COMPONENT_REGISTRY_TOKEN, LIMIT_ACTION_GLOBAL_TIME_RUN, ACTION_CONDITIONALS } from '@tramvai/tokens-common';
 import { EXTEND_RENDER } from '@tramvai/tokens-render';
 import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN } from '@tramvai/tokens-router';
@@ -18,7 +18,7 @@ const sharedProviders = [
     provide({
         provide: COMBINE_REDUCERS,
         multi: true,
-        useValue: ChildAppStore,
+        useValue: [ChildAppStore],
     }),
     provide({
         provide: commandLineListTokens.init,
@@ -29,6 +29,11 @@ const sharedProviders = [
         provide: CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
         useClass: ChildAppResolutionConfigManager,
         deps: {
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
+            plugins: {
+                optional: true,
+                token: CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+            },
             configs: { token: CHILD_APP_RESOLUTION_CONFIGS_TOKEN, optional: true },
             logger: LOGGER_TOKEN,
         },

package/lib/shared/providers.es.js

@@ -1,6 +1,6 @@
 import { Scope, DI_TOKEN, optional } from '@tinkoff/dippy';
-import { provide, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
-import { CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLUTION_CONFIGS_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RESOLVE_BASE_URL_TOKEN, CHILD_APP_SINGLETON_DI_MANAGER_TOKEN, CHILD_APP_LOADER_TOKEN, CHILD_APP_ROOT_DI_ACCESS_MODE_TOKEN, CHILD_APP_CONTRACT_MANAGER, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, HOST_PROVIDED_CONTRACTS, CHILD_APP_ERROR_BOUNDARY_TOKEN } from '@tramvai/tokens-child-app';
+import { provide, commandLineListTokens, TAPABLE_HOOK_FACTORY_TOKEN, COMMAND_LINE_RUNNER_TOKEN } from '@tramvai/core';
+import { CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_CONFIG_RESOLUTION_PLUGIN, CHILD_APP_RESOLUTION_CONFIGS_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RESOLVE_BASE_URL_TOKEN, CHILD_APP_SINGLETON_DI_MANAGER_TOKEN, CHILD_APP_LOADER_TOKEN, CHILD_APP_ROOT_DI_ACCESS_MODE_TOKEN, CHILD_APP_CONTRACT_MANAGER, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, HOST_PROVIDED_CONTRACTS, CHILD_APP_ERROR_BOUNDARY_TOKEN } from '@tramvai/tokens-child-app';
 import { COMBINE_REDUCERS, LOGGER_TOKEN, ENV_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, REGISTER_CLEAR_CACHE_TOKEN, CLEAR_CACHE_TOKEN, ENV_USED_TOKEN, COMPONENT_REGISTRY_TOKEN, LIMIT_ACTION_GLOBAL_TIME_RUN, ACTION_CONDITIONALS } from '@tramvai/tokens-common';
 import { EXTEND_RENDER } from '@tramvai/tokens-render';
 import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN, LINK_PREFETCH_MANAGER_TOKEN, ROUTER_SPA_ACTIONS_RUN_MODE_TOKEN } from '@tramvai/tokens-router';
@@ -18,7 +18,7 @@ const sharedProviders = [
     provide({
         provide: COMBINE_REDUCERS,
         multi: true,
-        useValue: ChildAppStore,
+        useValue: [ChildAppStore],
     }),
     provide({
         provide: commandLineListTokens.init,
@@ -29,6 +29,11 @@ const sharedProviders = [
         provide: CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
         useClass: ChildAppResolutionConfigManager,
         deps: {
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
+            plugins: {
+                optional: true,
+                token: CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+            },
             configs: { token: CHILD_APP_RESOLUTION_CONFIGS_TOKEN, optional: true },
             logger: LOGGER_TOKEN,
         },

package/lib/shared/providers.js

@@ -22,7 +22,7 @@ const sharedProviders = [
     core.provide({
         provide: tokensCommon.COMBINE_REDUCERS,
         multi: true,
-        useValue: store.ChildAppStore,
+        useValue: [store.ChildAppStore],
     }),
     core.provide({
         provide: core.commandLineListTokens.init,
@@ -33,6 +33,11 @@ const sharedProviders = [
         provide: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
         useClass: resolutionConfigManager.ChildAppResolutionConfigManager,
         deps: {
+            hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
+            plugins: {
+                optional: true,
+                token: tokensChildApp.CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+            },
             configs: { token: tokensChildApp.CHILD_APP_RESOLUTION_CONFIGS_TOKEN, optional: true },
             logger: tokensCommon.LOGGER_TOKEN,
         },

package/lib/shared/react/ChildAppErrorBoundary/ChildAppErrorBoundary.browser.js

@@ -0,0 +1,56 @@
+import { jsx } from 'react/jsx-runtime';
+import { Component } from 'react';
+import { FallbackError } from './FallbackError.browser.js';
+import { ChildAppFallbackWrapper } from '../ChildAppFallbackWrapper.browser.js';
+
+class ChildAppErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            error: props.error || null,
+            childAppLoadingStatus: null,
+        };
+    }
+    static displayName = 'ChildAppErrorBoundary';
+    static getDerivedStateFromProps(props, state) {
+        if (!props.childAppLoadingStatus) {
+            return { error: props.error || state.error };
+        }
+        if (state.childAppLoadingStatus &&
+            props.childAppLoadingStatus &&
+            props.childAppLoadingStatus !== state.childAppLoadingStatus) {
+            return { error: props.error || null, childAppLoadingStatus: props.childAppLoadingStatus };
+        }
+        return {
+            error: props.error || state.error,
+            childAppLoadingStatus: props.childAppLoadingStatus,
+        };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error, errorInfo) {
+        const { errorHandlers } = this.props;
+        if (errorHandlers) {
+            errorHandlers.forEach((handler) => {
+                handler(error, errorInfo);
+            });
+        }
+    }
+    render() {
+        const { children, fallback: Fallback, fallbackFromDi, config } = this.props;
+        const { error } = this.state;
+        if (!error) {
+            return children;
+        }
+        if (Fallback) {
+            return jsx(ChildAppFallbackWrapper, { fallback: Fallback, ...config, error: error });
+        }
+        if (fallbackFromDi) {
+            return fallbackFromDi;
+        }
+        return jsx(FallbackError, {});
+    }
+}
+
+export { ChildAppErrorBoundary };

package/lib/shared/react/ChildAppErrorBoundary/ChildAppErrorBoundary.d.ts

@@ -0,0 +1,45 @@
+import React, { Component } from 'react';
+import type { ExtractDependencyType } from '@tinkoff/dippy';
+import type { ERROR_BOUNDARY_TOKEN } from '@tramvai/react';
+import { ChildAppReactConfig } from '@tramvai/tokens-child-app';
+type AnyError = Error & {
+    [key: string]: any;
+};
+export interface ChildAppErrorBoundaryFallbackProps {
+    error: AnyError;
+}
+export interface ChildAppErrorBoundaryProps {
+    config: ChildAppReactConfig;
+    childAppLoadingStatus?: string;
+    error?: AnyError | null;
+    fallback?: React.ComponentType<ChildAppErrorBoundaryFallbackProps>;
+    errorHandlers?: ExtractDependencyType<typeof ERROR_BOUNDARY_TOKEN> | null;
+    /**
+     * @deprecated
+     */
+    fallbackFromDi?: React.ReactElement | null;
+    children?: React.ReactNode;
+}
+interface State {
+    error: AnyError | null;
+    childAppLoadingStatus?: string | null;
+}
+type Props = ChildAppErrorBoundaryProps;
+export declare class ChildAppErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static displayName: string;
+    static getDerivedStateFromProps(props: Props, state: State): {
+        error: AnyError | null;
+        childAppLoadingStatus?: undefined;
+    } | {
+        error: AnyError | null;
+        childAppLoadingStatus: string;
+    };
+    static getDerivedStateFromError(error: AnyError): {
+        error: AnyError;
+    };
+    componentDidCatch(error: AnyError, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};
+//# sourceMappingURL=ChildAppErrorBoundary.d.ts.map

package/lib/shared/react/ChildAppErrorBoundary/ChildAppErrorBoundary.es.js

@@ -0,0 +1,56 @@
+import { jsx } from 'react/jsx-runtime';
+import { Component } from 'react';
+import { FallbackError } from './FallbackError.es.js';
+import { ChildAppFallbackWrapper } from '../ChildAppFallbackWrapper.es.js';
+
+class ChildAppErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            error: props.error || null,
+            childAppLoadingStatus: null,
+        };
+    }
+    static displayName = 'ChildAppErrorBoundary';
+    static getDerivedStateFromProps(props, state) {
+        if (!props.childAppLoadingStatus) {
+            return { error: props.error || state.error };
+        }
+        if (state.childAppLoadingStatus &&
+            props.childAppLoadingStatus &&
+            props.childAppLoadingStatus !== state.childAppLoadingStatus) {
+            return { error: props.error || null, childAppLoadingStatus: props.childAppLoadingStatus };
+        }
+        return {
+            error: props.error || state.error,
+            childAppLoadingStatus: props.childAppLoadingStatus,
+        };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error, errorInfo) {
+        const { errorHandlers } = this.props;
+        if (errorHandlers) {
+            errorHandlers.forEach((handler) => {
+                handler(error, errorInfo);
+            });
+        }
+    }
+    render() {
+        const { children, fallback: Fallback, fallbackFromDi, config } = this.props;
+        const { error } = this.state;
+        if (!error) {
+            return children;
+        }
+        if (Fallback) {
+            return jsx(ChildAppFallbackWrapper, { fallback: Fallback, ...config, error: error });
+        }
+        if (fallbackFromDi) {
+            return fallbackFromDi;
+        }
+        return jsx(FallbackError, {});
+    }
+}
+
+export { ChildAppErrorBoundary };