@tramvai/module-child-app 5.50.0 → 5.53.78

package/lib/browser/loader.browser.js

@@ -6,14 +6,24 @@ const getModuleFromGlobal = (entry) => {
     return window[`child-app__${entry}`];
 };
 class BrowserLoader extends Loader {
-    constructor({ logger }) {
+    log;
+    initializedMap = new WeakMap();
+    map = new Map();
+    hookFactory;
+    loadModuleHook;
+    constructor({ logger, hookFactory, plugins, }) {
         super();
-        this.initializedMap = new WeakMap();
-        this.map = new Map();
+        this.hookFactory = hookFactory;
         this.log = logger('child-app:loader');
+        this.loadModuleHook = this.hookFactory.createAsync('childAppLoadModule');
+        this.loadModuleHook.tapPromise('childAppLoadModule', async (_, { config }) => {
+            return this.loadModule({ config });
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply({ loadModule: this.loadModuleHook });
+        });
     }
-    // eslint-disable-next-line max-statements
-    async load(config) {
+    async loadModule({ config }) {
         const moduleName = config.name;
         const childApp = await this.get(config);
         if (childApp) {
@@ -63,6 +73,9 @@ class BrowserLoader extends Loader {
         });
         return Promise.reject(new Error(`Error resolving child-app ${moduleName}`));
     }
+    async load(config) {
+        return this.loadModuleHook.callPromise({ config });
+    }
     async init(config) {
         const container = getModuleFromGlobal(config.client.entry);
         if (container) {

package/lib/browser/loader.d.ts

@@ -1,6 +1,7 @@
 import type { ChildApp } from '@tramvai/child-app-core';
-import type { ChildAppFinalConfig } from '@tramvai/tokens-child-app';
+import type { CHILD_APP_LOADER_PLUGIN, ChildAppFinalConfig } from '@tramvai/tokens-child-app';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { AsyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
 import { Loader } from '../shared/loader';
 import type { ModuleFederationContainer } from '../shared/webpack/moduleFederation';
 export declare const getModuleFromGlobal: (entry: string) => ModuleFederationContainer | undefined;
@@ -8,9 +9,16 @@ export declare class BrowserLoader extends Loader {
     private readonly log;
     private readonly initializedMap;
     private map;
-    constructor({ logger }: {
+    private hookFactory;
+    loadModuleHook: AsyncTapableHookInstance<{
+        config: ChildAppFinalConfig;
+    }, ChildApp | undefined>;
+    constructor({ logger, hookFactory, plugins, }: {
         logger: typeof LOGGER_TOKEN;
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
+        plugins: (typeof CHILD_APP_LOADER_PLUGIN)[] | null;
     });
+    private loadModule;
     load(config: ChildAppFinalConfig): Promise<ChildApp | undefined>;
     init(config: ChildAppFinalConfig): Promise<void>;
     get(config: ChildAppFinalConfig): ChildApp | undefined;

package/lib/browser/preload.browser.js

@@ -1,23 +1,76 @@
 import { CHILD_APP_PAGE_SERVICE_TOKEN } from '@tramvai/tokens-child-app';
 import { optional } from '@tinkoff/dippy';
-import { ChildAppStore } from '../shared/store.browser.js';
+import { setChildAppPreloadStatusOnClient, ChildAppStore } from '../shared/store.browser.js';
 import { getModuleFromGlobal } from './loader.browser.js';
 
 class PreloadManager {
-    constructor({ loader, runner, resolutionConfigManager, resolveExternalConfig, store, diManager, }) {
-        this.pageHasRendered = false;
-        this.pageHasLoaded = false;
-        this.currentlyPreloaded = new Map();
-        this.hasPreloadBefore = new Set();
-        this.notPreloadedForCurrentSpaNavigation = new Set();
-        this.hasInitialized = false;
-        this.map = new Map();
+    loader;
+    runner;
+    store;
+    resolutionConfigManager;
+    resolveExternalConfig;
+    diManager;
+    pageHasRendered = false;
+    pageHasLoaded = false;
+    currentlyPreloaded = new Map();
+    hasPreloadBefore = new Set();
+    notPreloadedForCurrentSpaNavigation = new Set();
+    hasInitialized = false;
+    map = new Map();
+    hookFactory;
+    hooks;
+    constructor({ loader, runner, resolutionConfigManager, resolveExternalConfig, store, diManager, hookFactory, plugins, }) {
         this.loader = loader;
         this.runner = runner;
         this.store = store;
         this.resolutionConfigManager = resolutionConfigManager;
         this.resolveExternalConfig = resolveExternalConfig;
         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.prefetchChildApp.tapPromise('prefetchChildApp', async (_, payload) => {
+            await this.prefetchChildAppHook(payload);
+        });
+        this.hooks.preloadChildApp.tapPromise('preloadChildApp', async (_, payload) => {
+            await this.preloadChildAppHook(payload);
+        });
+        this.hooks.runChildAppCommandLine.tapPromise('runChildAppCommandLine', async (_, payload) => {
+            await this.runChildAppCommandLineHook(payload);
+        });
+        plugins?.forEach((plugin) => {
+            plugin.apply(this.hooks);
+        });
+    }
+    async runChildAppCommandLineHook({ status, config, }) {
+        const childApp = this.loader.get(config);
+        if (!childApp) {
+            return;
+        }
+        await this.runner.run('client', status, config);
+    }
+    async prefetchChildAppHook({ config, route, }) {
+        await this.loader.load(config);
+        await this.resolveComponent(config, route);
+    }
+    async preloadChildAppHook({ config, route, }) {
+        await this.loader.load(config);
+        await this.resolveComponent(config, route);
+        await this.run('customer', config);
+        // do not block Child App preloading by "clear" stage (where actions executed),
+        // because in will delay Child App rendering
+        // TODO: do we need to wait this Child App stage in "afterSpaTransition"?
+        // TODO: Can be a race condition between Child App render and actions?
+        this.run('clear', config).catch((error) => {
+            if (process.env.NODE_ENV === 'development') {
+                // eslint-disable-next-line no-console
+                console.error('Child App command line error', error);
+            }
+        });
+        this.hasPreloadBefore.add(config.key);
     }
     async preload(request, route) {
         await this.init();
@@ -40,27 +93,30 @@ class PreloadManager {
                 // but in case render has happened load child-app as soon as possible
                 const promise = (async () => {
                     try {
-                        await this.loader.load(config);
-                        await this.resolveComponent(config, route);
-                        await this.run('customer', config);
-                        // do not block Child App preloading by "clear" stage (where actions executed),
-                        // because in will delay Child App rendering
-                        // TODO: do we need to wait this Child App stage in "afterSpaTransition"?
-                        // TODO: Can be a race condition between Child App render and actions?
-                        this.run('clear', config).catch((error) => {
-                            if (process.env.NODE_ENV === 'development') {
-                                // eslint-disable-next-line no-console
-                                console.error('Child App command line error', error);
-                            }
+                        await this.hooks.preloadChildApp.callPromise({
+                            config,
+                            route,
                         });
+                        this.store.dispatch(setChildAppPreloadStatusOnClient({
+                            [key]: {
+                                status: 'loaded',
+                            },
+                        }));
                     }
                     catch (error) {
                         if (process.env.NODE_ENV === 'development') {
                             // eslint-disable-next-line no-console
                             console.error('Child App loading error', error);
                         }
+                        this.hasPreloadBefore.delete(config.key);
+                        this.map.delete(config.key);
+                        this.store.dispatch(setChildAppPreloadStatusOnClient({
+                            [key]: {
+                                status: 'error',
+                            },
+                        }));
+                        return Promise.reject(error);
                     }
-                    this.hasPreloadBefore.add(key);
                 })();
                 this.map.set(key, promise);
                 return promise;
@@ -79,14 +135,14 @@ class PreloadManager {
         }
         if (!this.isPreloaded(config)) {
             try {
-                await this.loader.load(config);
-                await this.resolveComponent(config, route);
+                await this.hooks.prefetchChildApp.callPromise({ config, route });
             }
             catch (error) {
                 if (process.env.NODE_ENV === 'development') {
                     // eslint-disable-next-line no-console
                     console.error('Child App prefetch error', error);
                 }
+                return Promise.reject(error);
             }
         }
     }
@@ -176,11 +232,11 @@ class PreloadManager {
         await this.initServerPreloaded();
     }
     async run(status, config) {
-        const childApp = this.loader.get(config);
-        if (!childApp) {
-            return;
-        }
-        await this.runner.run('client', status, config);
+        await this.hooks.runChildAppCommandLine.callPromise({
+            config,
+            status,
+            line: 'client',
+        });
     }
     // preload child app page component - we need to register page actions before running all child app actions
     async resolveComponent(config, route) {

package/lib/browser/preload.d.ts

@@ -1,6 +1,7 @@
-import { type ChildAppCommandLineRunner, type ChildAppRequestConfig, type ChildAppLoader, type ChildAppPreloadManager, 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 { type ChildAppCommandLineRunner, type ChildAppRequestConfig, type ChildAppLoader, type ChildAppPreloadManager, type CHILD_APP_RESOLVE_CONFIG_TOKEN, type ChildAppFinalConfig, type CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, type CHILD_APP_DI_MANAGER_TOKEN, PreloadArgs, RunChildAppCommandLineArgs, CHILD_APP_PRELOAD_MANAGER_PLUGIN } from '@tramvai/tokens-child-app';
 import type { STORE_TOKEN } from '@tramvai/tokens-common';
 import type { Route } from '@tinkoff/router';
+import { AsyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
 export declare class PreloadManager implements ChildAppPreloadManager {
     private loader;
     private runner;
@@ -15,14 +16,25 @@ export declare class PreloadManager implements ChildAppPreloadManager {
     private notPreloadedForCurrentSpaNavigation;
     private hasInitialized;
     private map;
-    constructor({ loader, runner, resolutionConfigManager, resolveExternalConfig, store, diManager, }: {
+    private hookFactory;
+    hooks: {
+        preloadChildApp: AsyncTapableHookInstance<PreloadArgs>;
+        prefetchChildApp: AsyncTapableHookInstance<PreloadArgs>;
+        runChildAppCommandLine: AsyncTapableHookInstance<RunChildAppCommandLineArgs>;
+    };
+    constructor({ loader, runner, resolutionConfigManager, resolveExternalConfig, store, diManager, hookFactory, plugins, }: {
         loader: ChildAppLoader;
         runner: ChildAppCommandLineRunner;
         resolutionConfigManager: typeof CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN;
         resolveExternalConfig: typeof CHILD_APP_RESOLVE_CONFIG_TOKEN;
         store: typeof STORE_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 prefetchChildAppHook;
+    private preloadChildAppHook;
     preload(request: ChildAppRequestConfig, route?: Route): Promise<void>;
     prefetch(request: ChildAppRequestConfig, route?: Route): Promise<void>;
     isPreloaded(request: ChildAppRequestConfig): boolean;

package/lib/browser/providers.browser.js

@@ -1,6 +1,6 @@
 import { Scope, DI_TOKEN, optional } 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, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
+import { provide, TAPABLE_HOOK_FACTORY_TOKEN, commandLineListTokens } from '@tramvai/core';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_LOADER_PLUGIN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_PLUGIN, 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_RENDER_PLUGIN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_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';
@@ -16,6 +16,11 @@ const browserProviders = [
         useClass: BrowserLoader,
         scope: Scope.SINGLETON,
         deps: {
+            plugins: {
+                optional: true,
+                token: CHILD_APP_LOADER_PLUGIN,
+            },
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             logger: LOGGER_TOKEN,
         },
     }),
@@ -23,6 +28,11 @@ const browserProviders = [
         provide: CHILD_APP_PRELOAD_MANAGER_TOKEN,
         useClass: PreloadManager,
         deps: {
+            plugins: {
+                optional: true,
+                token: CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+            },
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             loader: CHILD_APP_LOADER_TOKEN,
             runner: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
             resolutionConfigManager: CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
@@ -39,6 +49,11 @@ const browserProviders = [
         provide: CHILD_APP_RENDER_MANAGER_TOKEN,
         useClass: RenderManager,
         deps: {
+            plugins: {
+                optional: true,
+                token: CHILD_APP_RENDER_PLUGIN,
+            },
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             logger: LOGGER_TOKEN,
             diManager: CHILD_APP_DI_MANAGER_TOKEN,
             preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,

package/lib/browser/render.browser.js

@@ -1,9 +1,23 @@
 class RenderManager {
-    constructor({ logger, preloadManager, diManager, resolveExternalConfig, }) {
+    preloadManager;
+    diManager;
+    resolveExternalConfig;
+    log;
+    hookFactory;
+    hooks;
+    constructor({ logger, preloadManager, diManager, resolveExternalConfig, hookFactory, plugins, }) {
+        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;
         this.resolveExternalConfig = resolveExternalConfig;
+        plugins?.forEach((plugin) => {
+            plugin.apply(this.hooks);
+        });
     }
     getChildDi(request) {
         const config = this.resolveExternalConfig(request);

package/lib/browser/render.d.ts

@@ -1,16 +1,24 @@
 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, CHILD_APP_RENDER_PLUGIN } from '@tramvai/tokens-child-app';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 export declare class RenderManager implements ChildAppRenderManager {
     private readonly preloadManager;
     private readonly diManager;
     private readonly resolveExternalConfig;
     private readonly log;
-    constructor({ logger, preloadManager, diManager, resolveExternalConfig, }: {
+    private hookFactory;
+    hooks: {
+        mounted: SyncTapableHookInstance<ChildAppConfigArgs>;
+        mountFailed: SyncTapableHookInstance<ChildAppConfigArgs>;
+    };
+    constructor({ logger, preloadManager, diManager, resolveExternalConfig, hookFactory, plugins, }: {
         logger: typeof LOGGER_TOKEN;
         preloadManager: ChildAppPreloadManager;
         diManager: ChildAppDiManager;
         resolveExternalConfig: typeof CHILD_APP_RESOLVE_CONFIG_TOKEN;
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
+        plugins: (typeof CHILD_APP_RENDER_PLUGIN)[] | null;
     });
     getChildDi(request: ChildAppRequestConfig): [Container | undefined, undefined | Promise<Container | undefined>];
     clear(): void;

package/lib/browser/runCommand.browser.js

@@ -1,4 +1,4 @@
-const runCommand = async ({ status, forcePreload, runner, preloader, diManager, pageService, logger, }) => {
+const runCommand = async ({ status, forcePreload, runner, preloader, pageService, logger, }) => {
     const childApps = preloader.getPreloadedList();
     const log = logger('child-app:run-preloaded');
     await Promise.all(childApps.map(async (config) => {

package/lib/browser/runCommand.d.ts

@@ -2,7 +2,7 @@ import type { CHILD_APP_DI_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
 import { type CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, type CHILD_APP_PRELOAD_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
-export declare const runCommand: ({ status, forcePreload, runner, preloader, diManager, pageService, logger, }: {
+export declare const runCommand: ({ status, forcePreload, runner, preloader, pageService, logger, }: {
     status: string;
     forcePreload: boolean;
     runner: typeof CHILD_APP_COMMAND_LINE_RUNNER_TOKEN;

package/lib/browser/timing.browser.js

@@ -0,0 +1,100 @@
+import { declareModule, provide, Scope } from '@tramvai/core';
+import { CHILD_APP_LOADER_PLUGIN, CHILD_APP_PRELOAD_MANAGER_PLUGIN, CHILD_APP_CONFIG_RESOLUTION_PLUGIN } from '@tramvai/tokens-child-app';
+
+const ChildAppMonitoringTimingModule = declareModule({
+    name: 'ChildAppMonitoringTiming',
+    providers: [
+        provide({
+            scope: Scope.SINGLETON,
+            provide: CHILD_APP_LOADER_PLUGIN,
+            useFactory: () => {
+                return {
+                    apply(hooks) {
+                        hooks.loadModule.wrap(async (_, payload, next) => {
+                            const childAppName = payload.config.name;
+                            const startKey = `child-app:load-module:${childAppName}:start`;
+                            const measureKey = `child-app:load-module:${childAppName}`;
+                            performance.mark(startKey);
+                            const childApp = await next(payload);
+                            const endKey = `child-app:load-module:${childAppName}:end`;
+                            performance.mark(endKey);
+                            performance.measure(measureKey, startKey, endKey);
+                            [startKey, endKey].forEach((name) => performance.clearMarks(name));
+                            return childApp;
+                        });
+                    },
+                };
+            },
+        }),
+        provide({
+            provide: CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+            useFactory: () => {
+                return {
+                    apply(hooks) {
+                        hooks.prefetchChildApp.wrap(async (_, payload, next) => {
+                            const childAppName = payload.config.name;
+                            const startKey = `child-app:prefetch:${childAppName}:start`;
+                            const endKey = `child-app:prefetch:${childAppName}:end`;
+                            const measureKey = `child-app:prefetch:${childAppName}`;
+                            performance.mark(startKey);
+                            await next(payload);
+                            performance.mark(endKey);
+                            performance.measure(measureKey, startKey, endKey);
+                            [startKey, endKey].forEach((name) => {
+                                performance.clearMarks(name);
+                            });
+                        });
+                        hooks.preloadChildApp.wrap(async (_, payload, next) => {
+                            const childAppName = payload.config.name;
+                            const startKey = `child-app:preload:${childAppName}:start`;
+                            const endKey = `child-app:preload:${childAppName}:end`;
+                            const measureKey = `child-app:preload:${childAppName}`;
+                            performance.mark(startKey);
+                            await next(payload);
+                            performance.mark(endKey);
+                            performance.measure(measureKey, startKey, endKey);
+                            [startKey, endKey].forEach((name) => {
+                                performance.clearMarks(name);
+                            });
+                        });
+                        hooks.runChildAppCommandLine.wrap(async (_, payload, next) => {
+                            const childAppName = payload.config.name;
+                            const startKey = `child-app:command-line-run:${childAppName}:${payload.line}:${payload.status}:start`;
+                            const endKey = `child-app:command-line-run:${childAppName}:${payload.line}:${payload.status}:end`;
+                            const measureKey = `child-app:command-line-run:${childAppName}:${payload.line}:${payload.status}`;
+                            performance.mark(startKey);
+                            await next(payload);
+                            performance.mark(endKey);
+                            performance.measure(measureKey, startKey, endKey);
+                            [startKey, endKey].forEach((name) => {
+                                performance.clearMarks(name);
+                            });
+                        });
+                    },
+                };
+            },
+        }),
+        provide({
+            provide: CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+            useFactory: () => {
+                return {
+                    apply(hooks) {
+                        hooks.fetchConfig.wrap(async (_, payload, next) => {
+                            const startKey = `child-app:fetch-config:start`;
+                            const measureKey = `child-app:fetch-config`;
+                            performance.mark(startKey);
+                            const configs = await next(payload);
+                            const endKey = `child-app:fetch-config:end`;
+                            performance.mark(endKey);
+                            performance.measure(measureKey, startKey, endKey);
+                            [startKey, endKey].forEach((name) => performance.clearMarks(name));
+                            return configs;
+                        });
+                    },
+                };
+            },
+        }),
+    ],
+});
+
+export { ChildAppMonitoringTimingModule };

package/lib/browser/timing.d.ts

@@ -0,0 +1,4 @@
+export declare const ChildAppMonitoringTimingModule: import("@tinkoff/dippy/lib/modules/module.h").ModuleClass & Partial<import("@tinkoff/dippy/lib/modules/module.h").ModuleSecretParameters> & {
+    [x: string]: (...args: any[]) => import("@tramvai/core").ModuleType;
+};
+//# sourceMappingURL=timing.d.ts.map

package/lib/browser.js

@@ -2,6 +2,7 @@ import { __decorate } from 'tslib';
 import { Module } from '@tramvai/core';
 import { sharedProviders } from './shared/providers.browser.js';
 import { browserProviders } from './browser/providers.browser.js';
+import { ChildAppMonitoringTimingModule } from './browser/timing.browser.js';
 export { Assert } from './export.browser.js';
 export { ChildApp } from './shared/react/component.browser.js';
 export * from '@tramvai/tokens-child-app';
@@ -10,7 +11,7 @@ let ChildAppModule = class ChildAppModule {
 };
 ChildAppModule = __decorate([
     Module({
-        imports: [],
+        imports: process.env.NODE_ENV === 'development' ? [ChildAppMonitoringTimingModule] : [],
         providers: [...sharedProviders, ...browserProviders],
     })
 ], ChildAppModule);

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

@@ -5,6 +5,10 @@ import { CHILD_APP_INTERNAL_CONFIG_TOKEN, IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKE
 
 /* eslint-disable no-console */
 class BaseChildAppContractManager {
+    appDi;
+    hostProvidedContracts;
+    hostRequiredContracts;
+    log;
     constructor({ appDi, hostProvidedContracts, hostRequiredContracts, logger, }) {
         this.appDi = appDi;
         this.hostProvidedContracts = hostProvidedContracts ?? [];

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

@@ -5,6 +5,10 @@ import { CHILD_APP_INTERNAL_CONFIG_TOKEN, IS_CHILD_APP_CONTRACTS_COMPATIBLE_TOKE
 
 /* eslint-disable no-console */
 class BaseChildAppContractManager {
+    appDi;
+    hostProvidedContracts;
+    hostRequiredContracts;
+    log;
     constructor({ appDi, hostProvidedContracts, hostRequiredContracts, logger, }) {
         this.appDi = appDi;
         this.hostProvidedContracts = hostProvidedContracts ?? [];

package/lib/contracts/contractManager.base.js

@@ -14,6 +14,10 @@ var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
 
 /* eslint-disable no-console */
 class BaseChildAppContractManager {
+    appDi;
+    hostProvidedContracts;
+    hostRequiredContracts;
+    log;
     constructor({ appDi, hostProvidedContracts, hostRequiredContracts, logger, }) {
         this.appDi = appDi;
         this.hostProvidedContracts = hostProvidedContracts ?? [];

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

@@ -4,6 +4,7 @@ import { CHILD_APP_INTERNAL_CONFIG_TOKEN, CHILD_APP_DI_MANAGER_TOKEN } from '@tr
 import { BaseChildAppContractManager } from './contractManager.base.es.js';
 
 class ChildAppContractManager extends BaseChildAppContractManager {
+    asyncLocalStorage;
     constructor({ appDi, asyncLocalStorage, hostProvidedContracts, hostRequiredContracts, logger, }) {
         super({
             appDi,

package/lib/contracts/contractManager.server.js

@@ -12,6 +12,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
 
 class ChildAppContractManager extends contractManager_base.BaseChildAppContractManager {
+    asyncLocalStorage;
     constructor({ appDi, asyncLocalStorage, hostProvidedContracts, hostRequiredContracts, logger, }) {
         super({
             appDi,

package/lib/server/loader.d.ts

@@ -1,21 +1,30 @@
-import type { ChildApp } from '@tramvai/child-app-core';
-import type { ChildAppFinalConfig } from '@tramvai/tokens-child-app';
-import type { CREATE_CACHE_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import type { CHILD_APP_LOADER_PLUGIN, ChildApp } from '@tramvai/child-app-core';
+import { CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN, type ChildAppFinalConfig } from '@tramvai/tokens-child-app';
+import type { CREATE_CACHE_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
+import { AsyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
 import { Loader } from '../shared/loader';
 import type { LoadableStats, ModuleFederationStats } from '../shared/webpack/moduleFederation';
 export declare class ServerLoader extends Loader {
     private readonly loader;
     private readonly initializedMap;
-    private internalLoadCache;
     private log;
-    constructor({ logger, createCache, envManager, }: {
+    private hookFactory;
+    loadModuleHook: AsyncTapableHookInstance<{
+        config: ChildAppFinalConfig;
+    }, ChildApp | undefined>;
+    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }: {
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
         logger: typeof LOGGER_TOKEN;
         createCache: typeof CREATE_CACHE_TOKEN;
         envManager: typeof ENV_MANAGER_TOKEN;
+        cacheOptions: typeof CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN | null;
+        asyncLocalStorage: typeof ASYNC_LOCAL_STORAGE_TOKEN | null;
+        plugins: (typeof CHILD_APP_LOADER_PLUGIN)[] | null;
     });
+    private loadModule;
     load(config: ChildAppFinalConfig): Promise<ChildApp | void>;
     init(config: ChildAppFinalConfig): Promise<void>;
-    get(config: ChildAppFinalConfig): ChildApp | void;
+    get(config: ChildAppFinalConfig): ChildApp | undefined;
     getStats(config: ChildAppFinalConfig): ModuleFederationStats | void;
     getLoadableStats(config: ChildAppFinalConfig): LoadableStats | void;
     waitFor(): Promise<void>;