@tramvai/module-child-app 5.50.0 → 5.53.74

package/lib/server/loader.es.js

@@ -4,25 +4,75 @@ import { Loader } from '../shared/loader.es.js';
 import { initModuleFederation, getModuleFederation } from '../shared/webpack/moduleFederation.es.js';
 
 class ServerLoader extends Loader {
-    constructor({ logger, createCache, envManager, }) {
+    loader;
+    initializedMap = new WeakMap();
+    log;
+    hookFactory;
+    loadModuleHook;
+    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }) {
         super();
-        this.initializedMap = new WeakMap();
+        this.hookFactory = hookFactory;
         const cache = createCache('memory', {
             name: 'child-app-loader',
             ttl: 1000 * 60 * 60 * 24 * 5,
-            max: 20,
+            // When Child App script is evicted from server loader cache, we get a small memory leak,
+            // because providers in singleton child DI, page components / actions, will store a reference to removed script,
+            // and server loader cache will contain a new instance of the same script.
+            //
+            // So, it is better to have bigger cache size to prevent evicting from cache,
+            // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
+            //
+            // TODO: cache cleanup for previous versions of Child Apps
+            max: 100,
+            ...cacheOptions,
         });
-        this.internalLoadCache = cache;
+        let internalLoadCache = cache;
+        // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
+        // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
+        // cache is only valid within the context of a single request.
+        if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
+            internalLoadCache = {
+                get(key) {
+                    if (key?.startsWith('__DEBUG__')) {
+                        const store = asyncLocalStorage.getStore();
+                        if (store) {
+                            return store[key];
+                        }
+                    }
+                    else {
+                        return cache.get(key);
+                    }
+                },
+                set(key, module) {
+                    if (key?.startsWith('__DEBUG__')) {
+                        const store = asyncLocalStorage.getStore();
+                        if (store) {
+                            store[key] = module;
+                        }
+                    }
+                    else {
+                        cache.set(key, module);
+                    }
+                },
+            };
+        }
         this.log = logger('child-app:loader');
         this.loader = new ServerLoader$1({
-            cache,
+            cache: internalLoadCache,
             log: this.log,
             requestOptions: {
                 circuitBreakerEnabled: isNil(envManager.get('HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED')),
             },
         });
+        this.loadModuleHook = this.hookFactory.createAsync('childAppLoadModule');
+        this.loadModuleHook.tapPromise('childAppLoadModule', async (_, payload) => {
+            return this.loadModule(payload);
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply({ loadModule: this.loadModuleHook });
+        });
     }
-    async load(config) {
+    async loadModule({ config }) {
         const promises = [
             this.loader.resolveByUrl(config.server.entry, {
                 codePrefix: `var ASSETS_PREFIX="${config.client.baseUrl}";`,
@@ -53,15 +103,12 @@ class ServerLoader extends Loader {
         }
         await Promise.all(promises);
         await this.init(config);
-        if (config.tag === 'debug') {
-            setTimeout(() => {
-                this.internalLoadCache.set(config.server.entry, null);
-                this.internalLoadCache.set(config.client.stats, null);
-                this.internalLoadCache.set(config.client.statsLoadable, null);
-            }, 10000);
-        }
         return this.get(config);
     }
+    async load(config) {
+        const childApp = await this.loadModuleHook.callPromise({ config });
+        return childApp;
+    }
     async init(config) {
         const container = this.loader.getByUrl(config.server.entry);
         if (!container) {
@@ -87,6 +134,9 @@ class ServerLoader extends Loader {
     }
     get(config) {
         const container = this.loader.getByUrl(config.server.entry);
+        if (!container) {
+            return undefined;
+        }
         const entry = container && this.initializedMap.get(container);
         return entry && this.resolve(entry);
     }

package/lib/server/loader.js

@@ -12,25 +12,75 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
 
 class ServerLoader extends loader.Loader {
-    constructor({ logger, createCache, envManager, }) {
+    loader;
+    initializedMap = new WeakMap();
+    log;
+    hookFactory;
+    loadModuleHook;
+    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }) {
         super();
-        this.initializedMap = new WeakMap();
+        this.hookFactory = hookFactory;
         const cache = createCache('memory', {
             name: 'child-app-loader',
             ttl: 1000 * 60 * 60 * 24 * 5,
-            max: 20,
+            // When Child App script is evicted from server loader cache, we get a small memory leak,
+            // because providers in singleton child DI, page components / actions, will store a reference to removed script,
+            // and server loader cache will contain a new instance of the same script.
+            //
+            // So, it is better to have bigger cache size to prevent evicting from cache,
+            // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
+            //
+            // TODO: cache cleanup for previous versions of Child Apps
+            max: 100,
+            ...cacheOptions,
         });
-        this.internalLoadCache = cache;
+        let internalLoadCache = cache;
+        // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
+        // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
+        // cache is only valid within the context of a single request.
+        if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
+            internalLoadCache = {
+                get(key) {
+                    if (key?.startsWith('__DEBUG__')) {
+                        const store = asyncLocalStorage.getStore();
+                        if (store) {
+                            return store[key];
+                        }
+                    }
+                    else {
+                        return cache.get(key);
+                    }
+                },
+                set(key, module) {
+                    if (key?.startsWith('__DEBUG__')) {
+                        const store = asyncLocalStorage.getStore();
+                        if (store) {
+                            store[key] = module;
+                        }
+                    }
+                    else {
+                        cache.set(key, module);
+                    }
+                },
+            };
+        }
         this.log = logger('child-app:loader');
         this.loader = new moduleLoaderServer.ServerLoader({
-            cache,
+            cache: internalLoadCache,
             log: this.log,
             requestOptions: {
                 circuitBreakerEnabled: isNil__default["default"](envManager.get('HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED')),
             },
         });
+        this.loadModuleHook = this.hookFactory.createAsync('childAppLoadModule');
+        this.loadModuleHook.tapPromise('childAppLoadModule', async (_, payload) => {
+            return this.loadModule(payload);
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply({ loadModule: this.loadModuleHook });
+        });
     }
-    async load(config) {
+    async loadModule({ config }) {
         const promises = [
             this.loader.resolveByUrl(config.server.entry, {
                 codePrefix: `var ASSETS_PREFIX="${config.client.baseUrl}";`,
@@ -61,15 +111,12 @@ class ServerLoader extends loader.Loader {
         }
         await Promise.all(promises);
         await this.init(config);
-        if (config.tag === 'debug') {
-            setTimeout(() => {
-                this.internalLoadCache.set(config.server.entry, null);
-                this.internalLoadCache.set(config.client.stats, null);
-                this.internalLoadCache.set(config.client.statsLoadable, null);
-            }, 10000);
-        }
         return this.get(config);
     }
+    async load(config) {
+        const childApp = await this.loadModuleHook.callPromise({ config });
+        return childApp;
+    }
     async init(config) {
         const container = this.loader.getByUrl(config.server.entry);
         if (!container) {
@@ -95,6 +142,9 @@ class ServerLoader extends loader.Loader {
     }
     get(config) {
         const container = this.loader.getByUrl(config.server.entry);
+        if (!container) {
+            return undefined;
+        }
         const entry = container && this.initializedMap.get(container);
         return entry && this.resolve(entry);
     }

package/lib/server/module-federation/best-loaded-shared-modules.d.ts

@@ -0,0 +1,15 @@
+import { SharedModule, SharedScopeItem } from './utils';
+export type SharedModuleWithChunks = {
+    shareKey: string;
+    from: string;
+    version: string;
+    eager: boolean;
+    childAppName?: string;
+    childAppVersion?: string;
+    chunks?: string[];
+};
+export declare function resolveBestLoadedSharedModules({ sharedModules, sharedScopeItems, }: {
+    sharedModules: SharedModule[];
+    sharedScopeItems: SharedScopeItem[];
+}): SharedModuleWithChunks[];
+//# sourceMappingURL=best-loaded-shared-modules.d.ts.map

package/lib/server/module-federation/best-loaded-shared-modules.es.js

@@ -0,0 +1,26 @@
+function resolveBestLoadedSharedModules({ sharedModules, sharedScopeItems, }) {
+    const result = [];
+    for (const sharedScopeItem of sharedScopeItems) {
+        const { shareKey, from, eager, loaded } = sharedScopeItem;
+        // we need only Child Apps deps, host app shared modules is always loaded on the client
+        // and we need to get only used shared modules, `loaded` flag means that module was required by MF runtime
+        // https://github.com/webpack/webpack/blob/97d4961cd1de9c69dba0f050a63f3b56bb64fab2/lib/sharing/ConsumeSharedRuntimeModule.js#L104
+        if (from.startsWith('child-app') && !!loaded) {
+            const sharedModule = sharedModules.find((m) => m.from === from && m.provides?.[0]?.shareKey === shareKey);
+            if (sharedModule) {
+                result.push({
+                    shareKey,
+                    from: sharedScopeItem.from,
+                    eager,
+                    version: sharedScopeItem.version,
+                    childAppName: sharedModule?.childAppName,
+                    childAppVersion: sharedModule?.childAppVersion,
+                    chunks: sharedModule?.chunks,
+                });
+            }
+        }
+    }
+    return result;
+}
+
+export { resolveBestLoadedSharedModules };

package/lib/server/module-federation/best-loaded-shared-modules.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function resolveBestLoadedSharedModules({ sharedModules, sharedScopeItems, }) {
+    const result = [];
+    for (const sharedScopeItem of sharedScopeItems) {
+        const { shareKey, from, eager, loaded } = sharedScopeItem;
+        // we need only Child Apps deps, host app shared modules is always loaded on the client
+        // and we need to get only used shared modules, `loaded` flag means that module was required by MF runtime
+        // https://github.com/webpack/webpack/blob/97d4961cd1de9c69dba0f050a63f3b56bb64fab2/lib/sharing/ConsumeSharedRuntimeModule.js#L104
+        if (from.startsWith('child-app') && !!loaded) {
+            const sharedModule = sharedModules.find((m) => m.from === from && m.provides?.[0]?.shareKey === shareKey);
+            if (sharedModule) {
+                result.push({
+                    shareKey,
+                    from: sharedScopeItem.from,
+                    eager,
+                    version: sharedScopeItem.version,
+                    childAppName: sharedModule?.childAppName,
+                    childAppVersion: sharedModule?.childAppVersion,
+                    chunks: sharedModule?.chunks,
+                });
+            }
+        }
+    }
+    return result;
+}
+
+exports.resolveBestLoadedSharedModules = resolveBestLoadedSharedModules;

package/lib/server/module-federation/best-shared-modules.d.ts

@@ -0,0 +1,15 @@
+import { SharedModule, SharedScopeItem } from './utils';
+export type SharedModuleWithChunks = {
+    shareKey: string;
+    from: string;
+    version: string;
+    eager: boolean;
+    childAppName?: string;
+    childAppVersion?: string;
+    chunks?: string[];
+};
+export declare function resolveBestSharedModules({ sharedModules, sharedScopeItems, }: {
+    sharedModules: SharedModule[];
+    sharedScopeItems: SharedScopeItem[];
+}): SharedModuleWithChunks[];
+//# sourceMappingURL=best-shared-modules.d.ts.map

package/lib/server/module-federation/utils.d.ts

@@ -0,0 +1,18 @@
+import { ChildAppFinalConfig } from '@tramvai/tokens-child-app';
+import { ModuleFederationSharedModule, ModuleFederationSharedScope, ModuleFederationSharedScopeItem } from '../../shared/webpack/moduleFederation';
+import { ServerLoader } from '../loader';
+export type SharedScopeItem = ModuleFederationSharedScopeItem & {
+    shareKey: string;
+    version: string;
+};
+export type SharedModule = ModuleFederationSharedModule & {
+    from: string;
+    childAppName: string;
+    childAppVersion: string;
+};
+export declare function getFlatSharedScopeItemsList(sharedScope: ModuleFederationSharedScope): SharedScopeItem[];
+export declare function getFlatSharedModulesList({ preloadedConfigs, loader, }: {
+    preloadedConfigs: ChildAppFinalConfig[];
+    loader: ServerLoader;
+}): SharedModule[];
+//# sourceMappingURL=utils.d.ts.map

package/lib/server/module-federation/utils.es.js

@@ -0,0 +1,38 @@
+function getFlatSharedScopeItemsList(sharedScope) {
+    // flat list of all shared items initialized in shared scope
+    const sharedScopeItems = [];
+    for (const shareKey in sharedScope) {
+        const sharedDependency = sharedScope[shareKey];
+        for (const version in sharedDependency) {
+            const sharedScopeItem = sharedDependency[version];
+            sharedScopeItems.push({
+                ...sharedScopeItem,
+                shareKey,
+                version,
+            });
+        }
+    }
+    return sharedScopeItems;
+}
+function getFlatSharedModulesList({ preloadedConfigs, loader, }) {
+    const sharedModules = [];
+    for (const config of preloadedConfigs) {
+        const stats = 'getStats' in loader ? loader.getStats(config) : undefined;
+        const from = `child-app:${config.name}:${config.version}`;
+        if (stats && stats.federatedModules) {
+            for (const federatedModule of stats.federatedModules) {
+                for (const sharedModule of federatedModule.sharedModules) {
+                    sharedModules.push({
+                        ...sharedModule,
+                        from,
+                        childAppName: config.name,
+                        childAppVersion: config.version,
+                    });
+                }
+            }
+        }
+    }
+    return sharedModules;
+}
+
+export { getFlatSharedModulesList, getFlatSharedScopeItemsList };

package/lib/server/module-federation/utils.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getFlatSharedScopeItemsList(sharedScope) {
+    // flat list of all shared items initialized in shared scope
+    const sharedScopeItems = [];
+    for (const shareKey in sharedScope) {
+        const sharedDependency = sharedScope[shareKey];
+        for (const version in sharedDependency) {
+            const sharedScopeItem = sharedDependency[version];
+            sharedScopeItems.push({
+                ...sharedScopeItem,
+                shareKey,
+                version,
+            });
+        }
+    }
+    return sharedScopeItems;
+}
+function getFlatSharedModulesList({ preloadedConfigs, loader, }) {
+    const sharedModules = [];
+    for (const config of preloadedConfigs) {
+        const stats = 'getStats' in loader ? loader.getStats(config) : undefined;
+        const from = `child-app:${config.name}:${config.version}`;
+        if (stats && stats.federatedModules) {
+            for (const federatedModule of stats.federatedModules) {
+                for (const sharedModule of federatedModule.sharedModules) {
+                    sharedModules.push({
+                        ...sharedModule,
+                        from,
+                        childAppName: config.name,
+                        childAppVersion: config.version,
+                    });
+                }
+            }
+        }
+    }
+    return sharedModules;
+}
+
+exports.getFlatSharedModulesList = getFlatSharedModulesList;
+exports.getFlatSharedScopeItemsList = getFlatSharedScopeItemsList;

package/lib/server/preload.d.ts

@@ -1,5 +1,6 @@
 import type { Route } from '@tinkoff/router';
-import { type ChildAppCommandLineRunner, type ChildAppRequestConfig, type ChildAppLoader, type ChildAppPreloadManager, type ChildAppStateManager, type CHILD_APP_RESOLVE_CONFIG_TOKEN, type ChildAppFinalConfig, type CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, type CHILD_APP_DI_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
+import { AsyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
+import { type ChildAppCommandLineRunner, type ChildAppRequestConfig, type ChildAppLoader, type ChildAppPreloadManager, type ChildAppStateManager, type CHILD_APP_RESOLVE_CONFIG_TOKEN, type ChildAppFinalConfig, type CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, type CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_PLUGIN, PreloadArgs, RunChildAppCommandLineArgs } from '@tramvai/tokens-child-app';
 export declare class PreloadManager implements ChildAppPreloadManager {
     private loader;
     private runner;
@@ -10,14 +11,24 @@ export declare class PreloadManager implements ChildAppPreloadManager {
     private shouldRunImmediately;
     private map;
     private preloadMap;
-    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, }: {
+    private hookFactory;
+    hooks: {
+        preloadChildApp: AsyncTapableHookInstance<PreloadArgs>;
+        prefetchChildApp: AsyncTapableHookInstance<PreloadArgs>;
+        runChildAppCommandLine: AsyncTapableHookInstance<RunChildAppCommandLineArgs>;
+    };
+    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, hookFactory, plugins, }: {
         loader: ChildAppLoader;
         runner: ChildAppCommandLineRunner;
         stateManager: ChildAppStateManager;
         resolutionConfigManager: typeof CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN;
         resolveFullConfig: typeof CHILD_APP_RESOLVE_CONFIG_TOKEN;
         diManager: typeof CHILD_APP_DI_MANAGER_TOKEN;
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
+        plugins: (typeof CHILD_APP_PRELOAD_MANAGER_PLUGIN)[] | null;
     });
+    private runChildAppCommandLineHook;
+    private preloadChildAppHook;
     preload(request: ChildAppRequestConfig, route?: Route): Promise<void>;
     prefetch(request: ChildAppRequestConfig, route?: Route): Promise<void>;
     isPreloaded(request: ChildAppRequestConfig): boolean;

package/lib/server/preload.es.js

@@ -2,28 +2,53 @@ import { optional } from '@tinkoff/dippy';
 import { CHILD_APP_PAGE_SERVICE_TOKEN } from '@tramvai/tokens-child-app';
 
 class PreloadManager {
-    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, }) {
-        this.shouldRunImmediately = false;
-        this.map = new Map();
-        this.preloadMap = new Map();
+    loader;
+    runner;
+    stateManager;
+    resolutionConfigManager;
+    resolveFullConfig;
+    diManager;
+    shouldRunImmediately = false;
+    map = new Map();
+    preloadMap = new Map();
+    hookFactory;
+    hooks;
+    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, hookFactory, plugins, }) {
         this.loader = loader;
         this.runner = runner;
         this.stateManager = stateManager;
         this.resolutionConfigManager = resolutionConfigManager;
         this.resolveFullConfig = resolveFullConfig;
         this.diManager = diManager;
+        this.hookFactory = hookFactory;
+        this.hooks = {
+            preloadChildApp: this.hookFactory.createAsync('preloadChildApp'),
+            prefetchChildApp: this.hookFactory.createAsync('prefetchChildApp'),
+            runChildAppCommandLine: this.hookFactory.createAsync('runChildAppCommandLine'),
+        };
+        this.hooks.preloadChildApp.tapPromise('childAppPreload', async (_, payload) => {
+            await this.preloadChildAppHook(payload);
+        });
+        this.hooks.prefetchChildApp.tapPromise('childAppPrefetch', async () => {
+            // do nothing at server side
+        });
+        this.hooks.runChildAppCommandLine.tapPromise('childAppCommandRun', async (_, payload) => {
+            await this.runChildAppCommandLineHook(payload);
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply(this.hooks);
+        });
     }
-    async preload(request, route) {
-        await this.resolutionConfigManager.init();
-        const config = this.resolveFullConfig(request);
-        if (!config) {
+    async runChildAppCommandLineHook({ config, status, }) {
+        const childApp = this.loader.get(config);
+        if (!childApp) {
             return;
         }
+        await this.runner.run('server', status, config);
+        await this.stateManager.registerChildApp(config);
+    }
+    async preloadChildAppHook({ config }) {
         const { key } = config;
-        if (this.map.has(key)) {
-            await this.map.get(key);
-            return;
-        }
         const promise = this.loader
             .load(config)
             .catch(() => {
@@ -47,8 +72,23 @@ class PreloadManager {
             await promise;
         }
     }
+    async preload(request, route) {
+        await this.resolutionConfigManager.init();
+        const config = this.resolveFullConfig(request);
+        if (!config) {
+            return;
+        }
+        const { key } = config;
+        if (this.map.has(key)) {
+            await this.map.get(key);
+        }
+        await this.hooks.preloadChildApp.callPromise({
+            config,
+            route,
+        });
+    }
     async prefetch(request, route) {
-        // do nothing at server-side
+        // do nothing on server side
     }
     isPreloaded(request) {
         const config = this.resolveFullConfig(request);
@@ -78,12 +118,11 @@ class PreloadManager {
         return Array.from(this.preloadMap.values());
     }
     async run(status, config) {
-        const childApp = this.loader.get(config);
-        if (!childApp) {
-            return;
-        }
-        await this.runner.run('server', status, config);
-        await this.stateManager.registerChildApp(config);
+        await this.hooks.runChildAppCommandLine.callPromise({
+            config,
+            status,
+            line: 'server',
+        });
     }
     saveNotPreloadedForSpaNavigation(request) {
         // do nothing at server-side

package/lib/server/preload.js

@@ -6,28 +6,53 @@ var dippy = require('@tinkoff/dippy');
 var tokensChildApp = require('@tramvai/tokens-child-app');
 
 class PreloadManager {
-    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, }) {
-        this.shouldRunImmediately = false;
-        this.map = new Map();
-        this.preloadMap = new Map();
+    loader;
+    runner;
+    stateManager;
+    resolutionConfigManager;
+    resolveFullConfig;
+    diManager;
+    shouldRunImmediately = false;
+    map = new Map();
+    preloadMap = new Map();
+    hookFactory;
+    hooks;
+    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, diManager, hookFactory, plugins, }) {
         this.loader = loader;
         this.runner = runner;
         this.stateManager = stateManager;
         this.resolutionConfigManager = resolutionConfigManager;
         this.resolveFullConfig = resolveFullConfig;
         this.diManager = diManager;
+        this.hookFactory = hookFactory;
+        this.hooks = {
+            preloadChildApp: this.hookFactory.createAsync('preloadChildApp'),
+            prefetchChildApp: this.hookFactory.createAsync('prefetchChildApp'),
+            runChildAppCommandLine: this.hookFactory.createAsync('runChildAppCommandLine'),
+        };
+        this.hooks.preloadChildApp.tapPromise('childAppPreload', async (_, payload) => {
+            await this.preloadChildAppHook(payload);
+        });
+        this.hooks.prefetchChildApp.tapPromise('childAppPrefetch', async () => {
+            // do nothing at server side
+        });
+        this.hooks.runChildAppCommandLine.tapPromise('childAppCommandRun', async (_, payload) => {
+            await this.runChildAppCommandLineHook(payload);
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply(this.hooks);
+        });
     }
-    async preload(request, route) {
-        await this.resolutionConfigManager.init();
-        const config = this.resolveFullConfig(request);
-        if (!config) {
+    async runChildAppCommandLineHook({ config, status, }) {
+        const childApp = this.loader.get(config);
+        if (!childApp) {
             return;
         }
+        await this.runner.run('server', status, config);
+        await this.stateManager.registerChildApp(config);
+    }
+    async preloadChildAppHook({ config }) {
         const { key } = config;
-        if (this.map.has(key)) {
-            await this.map.get(key);
-            return;
-        }
         const promise = this.loader
             .load(config)
             .catch(() => {
@@ -51,8 +76,23 @@ class PreloadManager {
             await promise;
         }
     }
+    async preload(request, route) {
+        await this.resolutionConfigManager.init();
+        const config = this.resolveFullConfig(request);
+        if (!config) {
+            return;
+        }
+        const { key } = config;
+        if (this.map.has(key)) {
+            await this.map.get(key);
+        }
+        await this.hooks.preloadChildApp.callPromise({
+            config,
+            route,
+        });
+    }
     async prefetch(request, route) {
-        // do nothing at server-side
+        // do nothing on server side
     }
     isPreloaded(request) {
         const config = this.resolveFullConfig(request);
@@ -82,12 +122,11 @@ class PreloadManager {
         return Array.from(this.preloadMap.values());
     }
     async run(status, config) {
-        const childApp = this.loader.get(config);
-        if (!childApp) {
-            return;
-        }
-        await this.runner.run('server', status, config);
-        await this.stateManager.registerChildApp(config);
+        await this.hooks.runChildAppCommandLine.callPromise({
+            config,
+            status,
+            line: 'server',
+        });
     }
     saveNotPreloadedForSpaNavigation(request) {
         // do nothing at server-side