@tramvai/module-child-app 5.49.1 → 6.59.0

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

package/lib/server/providers.es.js

@@ -1,9 +1,9 @@
 import { combineValidators, isUrl, endsWith } from '@tinkoff/env-validators';
 import { Scope, optional, DI_TOKEN } from '@tinkoff/dippy';
-import { provide, commandLineListTokens } from '@tramvai/core';
-import { ENV_USED_TOKEN, LOGGER_TOKEN, CREATE_CACHE_TOKEN, ENV_MANAGER_TOKEN, STORE_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
+import { provide, TAPABLE_HOOK_FACTORY_TOKEN, commandLineListTokens } from '@tramvai/core';
+import { ENV_USED_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, STORE_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
 import { RESOURCES_REGISTRY, RENDER_SLOTS, ResourceType, ResourceSlot, RENDER_FLOW_AFTER_TOKEN, REACT_SERVER_RENDER_MODE, EXTEND_RENDER } from '@tramvai/tokens-render';
-import { CHILD_APP_LOADER_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_LOADER_PLUGIN, CHILD_APP_LOADER_CACHE_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, 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_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
 import { safeStringify } from '@tramvai/safe-strings';
 import { ServerLoader } from './loader.es.js';
 import { PreloadManager } from './preload.es.js';
@@ -13,8 +13,10 @@ import { RenderManager } from './render.es.js';
 import { registerChildAppRenderSlots } from './render-slots.es.js';
 import { GLOBAL_CHILD_STATE } from '../shared/constants.es.js';
 import { ChildAppContractManager } from '../contracts/contractManager.server.es.js';
+import { cache } from './cache/cache.es.js';
 
 const serverProviders = [
+    ...cache,
     provide({
         provide: ENV_USED_TOKEN,
         multi: true,
@@ -31,8 +33,13 @@ const serverProviders = [
         useClass: ServerLoader,
         scope: Scope.SINGLETON,
         deps: {
+            plugins: {
+                optional: true,
+                token: CHILD_APP_LOADER_PLUGIN,
+            },
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             logger: LOGGER_TOKEN,
-            createCache: CREATE_CACHE_TOKEN,
+            cache: CHILD_APP_LOADER_CACHE_TOKEN,
             envManager: ENV_MANAGER_TOKEN,
         },
     }),
@@ -49,6 +56,11 @@ const serverProviders = [
         provide: CHILD_APP_PRELOAD_MANAGER_TOKEN,
         useClass: PreloadManager,
         deps: {
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
+            plugins: {
+                optional: true,
+                token: CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+            },
             loader: CHILD_APP_LOADER_TOKEN,
             runner: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
             stateManager: CHILD_APP_STATE_MANAGER_TOKEN,
@@ -102,6 +114,7 @@ const serverProviders = [
         provide: CHILD_APP_RENDER_MANAGER_TOKEN,
         useClass: RenderManager,
         deps: {
+            hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             logger: LOGGER_TOKEN,
             diManager: CHILD_APP_DI_MANAGER_TOKEN,
             preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,

package/lib/server/providers.js

@@ -17,8 +17,10 @@ var render = require('./render.js');
 var renderSlots = require('./render-slots.js');
 var constants = require('../shared/constants.js');
 var contractManager_server = require('../contracts/contractManager.server.js');
+var cache = require('./cache/cache.js');
 
 const serverProviders = [
+    ...cache.cache,
     core.provide({
         provide: tokensCommon.ENV_USED_TOKEN,
         multi: true,
@@ -35,8 +37,13 @@ const serverProviders = [
         useClass: loader.ServerLoader,
         scope: dippy.Scope.SINGLETON,
         deps: {
+            plugins: {
+                optional: true,
+                token: tokensChildApp.CHILD_APP_LOADER_PLUGIN,
+            },
+            hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
             logger: tokensCommon.LOGGER_TOKEN,
-            createCache: tokensCommon.CREATE_CACHE_TOKEN,
+            cache: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
             envManager: tokensCommon.ENV_MANAGER_TOKEN,
         },
     }),
@@ -53,6 +60,11 @@ const serverProviders = [
         provide: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
         useClass: preload.PreloadManager,
         deps: {
+            hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
+            plugins: {
+                optional: true,
+                token: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+            },
             loader: tokensChildApp.CHILD_APP_LOADER_TOKEN,
             runner: tokensChildApp.CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
             stateManager: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
@@ -106,6 +118,7 @@ const serverProviders = [
         provide: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
         useClass: render.RenderManager,
         deps: {
+            hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
             logger: tokensCommon.LOGGER_TOKEN,
             diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
             preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,

package/lib/server/render-slots.es.js

@@ -1,10 +1,11 @@
 import { extname } from 'path';
-import { gt, eq } from 'semver';
 import flatten from '@tinkoff/utils/array/flatten';
 import { resolve } from '@tinkoff/url';
 import { CHILD_APP_INTERNAL_CHUNK_EXTRACTOR } from '@tramvai/tokens-child-app';
 import { RENDER_SLOTS, ResourceType, ResourceSlot } from '@tramvai/tokens-render';
 import { getSharedScope } from '../shared/webpack/moduleFederation.es.js';
+import { getFlatSharedScopeItemsList, getFlatSharedModulesList } from './module-federation/utils.es.js';
+import { resolveBestLoadedSharedModules } from './module-federation/best-loaded-shared-modules.es.js';
 
 const asyncScriptAttrs = {
     defer: null,
@@ -18,14 +19,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
@@ -64,36 +67,25 @@ const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, pre
     };
     const preloadedList = new Set(preloadManager.getPreloadedList());
     const sharedScope = 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
-                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
-                (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 = getFlatSharedScopeItemsList(sharedScope);
+    // flat list of all preloaded Child Apps shared modules
+    const sharedModules = getFlatSharedModulesList({
+        preloadedConfigs,
+        loader: loader,
+    });
+    // optimal shared dependencies for preloaded Child Apps
+    const bestSharedModules = 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(CHILD_APP_INTERNAL_CHUNK_EXTRACTOR)?.getMainAssets();
@@ -123,21 +115,6 @@ const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, pre
                 for (const file of files) {
                     addChunk(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(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) {
@@ -153,13 +130,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(resolve(childAppConfig.client.baseUrl, chunk));
+                    const containerName = `child-app__${childAppConfig.client.entry}`;
+                    serializableSharedModules.push({
+                        containerName,
+                        shareKey,
+                        version,
+                        childAppName: childAppName,
+                        childAppVersion: childAppVersion,
+                    });
+                }
+            }
+        }
+    });
+    result.push({
+        type: ResourceType.inlineScript,
+        slot: ResourceSlot.HEAD_POLYFILLS,
+        payload: `window.__webpack_share_preloaded__ = [
+${serializableSharedModules.map((m) => {
+            return `${JSON.stringify(m)}`;
+        })}
+];`,
+    });
     result.map((item) => resourcesRegistry.register(item));
 };