@tramvai/module-child-app 5.49.1 → 6.59.0

package/lib/server/cache/cache.es.js

@@ -0,0 +1,76 @@
+import { provide, commandLineListTokens } from '@tramvai/core';
+import { optional, Scope } from '@tinkoff/dippy';
+import { CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN, CHILD_APP_LOADER_CACHE_TOKEN, CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN } from '@tramvai/tokens-child-app';
+import { ASYNC_LOCAL_STORAGE_TOKEN, CREATE_CACHE_TOKEN } from '@tramvai/tokens-common';
+import { setCacheCleanupInterval } from './cacheCleanup.es.js';
+
+const cache = [
+    provide({
+        provide: commandLineListTokens.listen,
+        useFactory: ({ childAppLoaderCache, cacheCleanupConfig }) => {
+            return () => {
+                setCacheCleanupInterval(childAppLoaderCache, cacheCleanupConfig?.cleanupIntervalMs);
+            };
+        },
+        deps: {
+            cacheCleanupConfig: optional(CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN),
+            childAppLoaderCache: CHILD_APP_LOADER_CACHE_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_LOADER_CACHE_TOKEN,
+        scope: Scope.SINGLETON,
+        useFactory: ({ createCache, cacheOptions, asyncLocalStorage }) => {
+            const inMemoryCache = createCache('memory', {
+                name: 'child-app-loader',
+                // 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.
+                max: 100,
+                ttl: 1000 * 60 * 60 * 24 * 5,
+                ...cacheOptions,
+            });
+            let childAppLoaderCache = inMemoryCache;
+            // 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) {
+                childAppLoaderCache = {
+                    get(key) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                return store[key];
+                            }
+                        }
+                        else {
+                            return inMemoryCache.get(key);
+                        }
+                    },
+                    set(key, module) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                store[key] = module;
+                            }
+                        }
+                        else {
+                            inMemoryCache.set(key, module);
+                        }
+                    },
+                };
+            }
+            return childAppLoaderCache;
+        },
+        deps: {
+            asyncLocalStorage: optional(ASYNC_LOCAL_STORAGE_TOKEN),
+            cacheOptions: optional(CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            createCache: CREATE_CACHE_TOKEN,
+        },
+    }),
+];
+
+export { cache };

package/lib/server/cache/cache.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var dippy = require('@tinkoff/dippy');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokensCommon = require('@tramvai/tokens-common');
+var cacheCleanup = require('./cacheCleanup.js');
+
+const cache = [
+    core.provide({
+        provide: core.commandLineListTokens.listen,
+        useFactory: ({ childAppLoaderCache, cacheCleanupConfig }) => {
+            return () => {
+                cacheCleanup.setCacheCleanupInterval(childAppLoaderCache, cacheCleanupConfig?.cleanupIntervalMs);
+            };
+        },
+        deps: {
+            cacheCleanupConfig: dippy.optional(tokensChildApp.CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN),
+            childAppLoaderCache: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
+        scope: dippy.Scope.SINGLETON,
+        useFactory: ({ createCache, cacheOptions, asyncLocalStorage }) => {
+            const inMemoryCache = createCache('memory', {
+                name: 'child-app-loader',
+                // 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.
+                max: 100,
+                ttl: 1000 * 60 * 60 * 24 * 5,
+                ...cacheOptions,
+            });
+            let childAppLoaderCache = inMemoryCache;
+            // 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) {
+                childAppLoaderCache = {
+                    get(key) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                return store[key];
+                            }
+                        }
+                        else {
+                            return inMemoryCache.get(key);
+                        }
+                    },
+                    set(key, module) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                store[key] = module;
+                            }
+                        }
+                        else {
+                            inMemoryCache.set(key, module);
+                        }
+                    },
+                };
+            }
+            return childAppLoaderCache;
+        },
+        deps: {
+            asyncLocalStorage: dippy.optional(tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN),
+            cacheOptions: dippy.optional(tokensChildApp.CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            createCache: tokensCommon.CREATE_CACHE_TOKEN,
+        },
+    }),
+];
+
+exports.cache = cache;

package/lib/server/cache/cacheCleanup.d.ts

@@ -0,0 +1,4 @@
+import { Cache } from '@tramvai/tokens-common';
+export declare function cleanupStaleElementsInCache<T>(cache: Cache<T>): void;
+export declare function setCacheCleanupInterval<T>(cache: Cache<T>, intervalMs?: number): void;
+//# sourceMappingURL=cacheCleanup.d.ts.map

package/lib/server/cache/cacheCleanup.es.js

@@ -0,0 +1,16 @@
+function cleanupStaleElementsInCache(cache) {
+    const entries = cache.dump();
+    const now = Date.now();
+    for (const [key, value] of entries) {
+        if (value.start + value.ttl < now) {
+            cache.delete(key);
+        }
+    }
+}
+function setCacheCleanupInterval(cache, intervalMs = 1000 * 60 * 60 * 24) {
+    setInterval(() => {
+        cleanupStaleElementsInCache(cache);
+    }, intervalMs);
+}
+
+export { cleanupStaleElementsInCache, setCacheCleanupInterval };

package/lib/server/cache/cacheCleanup.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function cleanupStaleElementsInCache(cache) {
+    const entries = cache.dump();
+    const now = Date.now();
+    for (const [key, value] of entries) {
+        if (value.start + value.ttl < now) {
+            cache.delete(key);
+        }
+    }
+}
+function setCacheCleanupInterval(cache, intervalMs = 1000 * 60 * 60 * 24) {
+    setInterval(() => {
+        cleanupStaleElementsInCache(cache);
+    }, intervalMs);
+}
+
+exports.cleanupStaleElementsInCache = cleanupStaleElementsInCache;
+exports.setCacheCleanupInterval = setCacheCleanupInterval;

package/lib/server/loader.d.ts

@@ -1,21 +1,28 @@
-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_TOKEN, type ChildAppFinalConfig } from '@tramvai/tokens-child-app';
+import type { LOGGER_TOKEN, ENV_MANAGER_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, envManager, cache, hookFactory, plugins, }: {
+        hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
         logger: typeof LOGGER_TOKEN;
-        createCache: typeof CREATE_CACHE_TOKEN;
         envManager: typeof ENV_MANAGER_TOKEN;
+        cache: typeof CHILD_APP_LOADER_CACHE_TOKEN;
+        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>;

package/lib/server/loader.es.js

@@ -4,15 +4,14 @@ 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, envManager, cache, hookFactory, plugins, }) {
         super();
-        this.initializedMap = new WeakMap();
-        const cache = createCache('memory', {
-            name: 'child-app-loader',
-            ttl: 1000 * 60 * 60 * 24 * 5,
-            max: 20,
-        });
-        this.internalLoadCache = cache;
+        this.hookFactory = hookFactory;
         this.log = logger('child-app:loader');
         this.loader = new ServerLoader$1({
             cache,
@@ -21,13 +20,21 @@ class ServerLoader extends Loader {
                 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}";`,
                 displayName: config.name,
                 kind: 'child-app',
+                debug: config.tag === 'debug',
             }),
             this.loader
                 .resolveByUrl(config.client.stats, {
@@ -35,6 +42,7 @@ class ServerLoader extends Loader {
                 kind: 'child-app stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without stats
                 .catch(() => { }),
@@ -46,6 +54,7 @@ class ServerLoader extends Loader {
                 kind: 'child-app loadable stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without loadable stats, for backward compatibility is ok
                 // but hydration errors will occur when lazy component will loaded at client-side at demand
@@ -53,17 +62,16 @@ 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);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return;
         }
@@ -86,12 +94,19 @@ class ServerLoader extends Loader {
         }
     }
     get(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
+        if (!container) {
+            return undefined;
+        }
         const entry = container && this.initializedMap.get(container);
         return entry && this.resolve(entry);
     }
     getStats(config) {
-        return this.loader.getByUrl(config.client.stats);
+        return this.loader.getByUrl(config.client.stats, {
+            debug: config.tag === 'debug',
+        });
     }
     getLoadableStats(config) {
         if (!config.client.statsLoadable) {

package/lib/server/loader.js

@@ -12,15 +12,14 @@ 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, envManager, cache, hookFactory, plugins, }) {
         super();
-        this.initializedMap = new WeakMap();
-        const cache = createCache('memory', {
-            name: 'child-app-loader',
-            ttl: 1000 * 60 * 60 * 24 * 5,
-            max: 20,
-        });
-        this.internalLoadCache = cache;
+        this.hookFactory = hookFactory;
         this.log = logger('child-app:loader');
         this.loader = new moduleLoaderServer.ServerLoader({
             cache,
@@ -29,13 +28,21 @@ class ServerLoader extends loader.Loader {
                 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}";`,
                 displayName: config.name,
                 kind: 'child-app',
+                debug: config.tag === 'debug',
             }),
             this.loader
                 .resolveByUrl(config.client.stats, {
@@ -43,6 +50,7 @@ class ServerLoader extends loader.Loader {
                 kind: 'child-app stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without stats
                 .catch(() => { }),
@@ -54,6 +62,7 @@ class ServerLoader extends loader.Loader {
                 kind: 'child-app loadable stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without loadable stats, for backward compatibility is ok
                 // but hydration errors will occur when lazy component will loaded at client-side at demand
@@ -61,17 +70,16 @@ 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);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return;
         }
@@ -94,12 +102,19 @@ class ServerLoader extends loader.Loader {
         }
     }
     get(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
+        if (!container) {
+            return undefined;
+        }
         const entry = container && this.initializedMap.get(container);
         return entry && this.resolve(entry);
     }
     getStats(config) {
-        return this.loader.getByUrl(config.client.stats);
+        return this.loader.getByUrl(config.client.stats, {
+            debug: config.tag === 'debug',
+        });
     }
     getLoadableStats(config) {
         if (!config.client.statsLoadable) {

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;