@module-federation/modern-js 0.0.0-chore-bump-node-22-20260710161714

package/dist/esm/ssr-runtime/SSRLiveReload.mjs

@@ -0,0 +1,23 @@
+import { _ } from "@swc/helpers/_/_tagged_template_literal";
+import { jsx } from "react/jsx-runtime";
+import "react";
+function SSRLiveReload_templateObject() {
+    var data = _([
+        "\n      if(",
+        "){\n        location.reload();\n      }\n   "
+    ]);
+    SSRLiveReload_templateObject = function() {
+        return data;
+    };
+    return data;
+}
+function SSRLiveReload() {
+    if ('development' !== process.env.NODE_ENV) return null;
+    return /*#__PURE__*/ jsx("script", {
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: {
+            __html: String.raw(SSRLiveReload_templateObject(), globalThis.shouldUpdate)
+        }
+    });
+}
+export { SSRLiveReload };

package/dist/esm/ssr-runtime/devPlugin.mjs

@@ -0,0 +1,70 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread__ } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload.mjs";
+import { flushDataFetch } from "@module-federation/bridge-react/data-fetch";
+var devPlugin_mfSSRDevPlugin = function() {
+    return {
+        name: '@module-federation/modern-js',
+        setup: function(api) {
+            api.onBeforeRender(function() {
+                return _(function() {
+                    var nodeUtils, shouldUpdate;
+                    return _ts_generator__(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if ("u" > typeof window) return [
+                                    2
+                                ];
+                                globalThis.shouldUpdate = false;
+                                return [
+                                    4,
+                                    import("@module-federation/node/utils")
+                                ];
+                            case 1:
+                                nodeUtils = _state.sent();
+                                return [
+                                    4,
+                                    nodeUtils.revalidate()
+                                ];
+                            case 2:
+                                shouldUpdate = _state.sent();
+                                console.log('shouldUpdate: ', shouldUpdate);
+                                if (!shouldUpdate) return [
+                                    3,
+                                    4
+                                ];
+                                console.log('should RELOAD', shouldUpdate);
+                                return [
+                                    4,
+                                    nodeUtils.flushChunks()
+                                ];
+                            case 3:
+                                _state.sent();
+                                flushDataFetch();
+                                globalThis.shouldUpdate = true;
+                                _state.label = 4;
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            });
+            api.wrapRoot(function(App) {
+                var AppWrapper = function(props) {
+                    return /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(SSRLiveReload, {}),
+                            /*#__PURE__*/ jsx(App, _object_spread__({}, props))
+                        ]
+                    });
+                };
+                return AppWrapper;
+            });
+        }
+    };
+};
+export { devPlugin_mfSSRDevPlugin as mfSSRDevPlugin };

package/dist/esm/ssr-runtime/injectDataFetchFunctionPlugin.mjs

@@ -0,0 +1,33 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { callDataFetch, setSSREnv } from "@module-federation/bridge-react/data-fetch";
+var injectDataFetchFunctionPlugin_injectDataFetchFunctionPlugin = function(param) {
+    var fetchServerQuery = param.fetchServerQuery;
+    return {
+        name: '@module-federation/inject-data-fetch-function-plugin',
+        setup: function(api) {
+            api.onBeforeRender(function() {
+                return _(function() {
+                    return _ts_generator__(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                setSSREnv({
+                                    fetchServerQuery: fetchServerQuery
+                                });
+                                return [
+                                    4,
+                                    callDataFetch()
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            });
+        }
+    };
+};
+export { injectDataFetchFunctionPlugin_injectDataFetchFunctionPlugin as injectDataFetchFunctionPlugin };

package/dist/esm-node/cli/configPlugin.mjs

@@ -0,0 +1,276 @@
+import * as __rspack_external_jiti from "jiti";
+import fs from "fs";
+import path from "path";
+import { isDev, isWebTarget, skipByTarget } from "./utils.mjs";
+import { encodeName } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "../constant.mjs";
+import { addDataFetchExposes, autoDeleteSplitChunkCacheGroups } from "@module-federation/rsbuild-plugin/utils";
+import logger from "../logger.mjs";
+var __webpack_modules__ = {
+    jiti (module) {
+        module.exports = __rspack_external_jiti;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const defaultPath = path.resolve(process.cwd(), 'module-federation.config.ts');
+const resolvePackageFile = (packageName, esmRelativePath, cjsRelativePath)=>{
+    const packageEntry = require.resolve(packageName);
+    let packageRoot = path.dirname(packageEntry);
+    while(!fs.existsSync(path.join(packageRoot, 'package.json'))){
+        const parentDir = path.dirname(packageRoot);
+        if (parentDir === packageRoot) throw new Error(`Unable to resolve package root for ${packageName} from ${packageEntry}`);
+        packageRoot = parentDir;
+    }
+    return require.resolve(path.join(packageRoot, 'true' === process.env['IS_ESM_BUILD'] ? esmRelativePath : cjsRelativePath));
+};
+const resolveSharedStrategyPlugin = ()=>resolvePackageFile('@module-federation/modern-js', 'dist/esm/cli/mfRuntimePlugins/shared-strategy.mjs', 'dist/cjs/cli/mfRuntimePlugins/shared-strategy.js');
+const resolveInjectNodeFetchPlugin = ()=>resolvePackageFile('@module-federation/modern-js', 'dist/esm/cli/mfRuntimePlugins/inject-node-fetch.mjs', 'dist/cjs/cli/mfRuntimePlugins/inject-node-fetch.js');
+const resolveNodeRuntimePlugin = ()=>resolvePackageFile('@module-federation/node', 'dist/src/runtimePlugin.mjs', 'dist/src/runtimePlugin.js');
+const resolveNodeRecordRemoteHashPlugin = ()=>resolvePackageFile('@module-federation/node', 'dist/src/recordDynamicRemoteEntryHashPlugin.mjs', 'dist/src/recordDynamicRemoteEntryHashPlugin.js');
+function setEnv(enableSSR) {
+    if (enableSSR) process.env['MF_SSR_PRJ'] = 'true';
+}
+const getMFConfig = async (userConfig)=>{
+    const { config, configPath } = userConfig;
+    if (config) return config;
+    const mfConfigPath = configPath ? configPath : defaultPath;
+    const { createJiti } = __webpack_require__("jiti");
+    const jit = createJiti(__filename, {
+        interopDefault: true
+    });
+    const configModule = await jit(mfConfigPath);
+    const resolvedConfig = configModule && 'object' == typeof configModule && 'default' in configModule ? configModule.default : configModule;
+    return resolvedConfig;
+};
+const injectRuntimePlugins = (runtimePlugin, runtimePlugins)=>{
+    const pluginName = 'string' == typeof runtimePlugin ? runtimePlugin : runtimePlugin[0];
+    const hasPlugin = runtimePlugins.some((existingPlugin)=>{
+        if ('string' == typeof existingPlugin) return existingPlugin === pluginName;
+        return existingPlugin[0] === pluginName;
+    });
+    if (!hasPlugin) runtimePlugins.push(runtimePlugin);
+};
+const patchDTSConfig = (mfConfig, isServer)=>{
+    if (isServer) return;
+    const ModernJSRuntime = '@module-federation/modern-js/runtime';
+    if (false !== mfConfig.dts) {
+        var _mfConfig_dts, _mfConfig_dts1;
+        if ('boolean' == typeof mfConfig.dts || void 0 === mfConfig.dts) mfConfig.dts = {
+            consumeTypes: {
+                runtimePkgs: [
+                    ModernJSRuntime
+                ]
+            }
+        };
+        else if ((null == (_mfConfig_dts = mfConfig.dts) ? void 0 : _mfConfig_dts.consumeTypes) || (null == (_mfConfig_dts1 = mfConfig.dts) ? void 0 : _mfConfig_dts1.consumeTypes) === void 0) {
+            var _mfConfig_dts2;
+            if ('boolean' == typeof mfConfig.dts.consumeTypes || (null == (_mfConfig_dts2 = mfConfig.dts) ? void 0 : _mfConfig_dts2.consumeTypes) === void 0) mfConfig.dts.consumeTypes = {
+                runtimePkgs: [
+                    ModernJSRuntime
+                ]
+            };
+            else {
+                mfConfig.dts.consumeTypes.runtimePkgs = mfConfig.dts.consumeTypes.runtimePkgs || [];
+                if (!mfConfig.dts.consumeTypes.runtimePkgs.includes(ModernJSRuntime)) mfConfig.dts.consumeTypes.runtimePkgs.push(ModernJSRuntime);
+            }
+        }
+    }
+};
+const patchMFConfig = (mfConfig, isServer)=>{
+    addDataFetchExposes(mfConfig.exposes, isServer);
+    if (void 0 === mfConfig.remoteType) mfConfig.remoteType = "script";
+    if (!mfConfig.name) throw new Error(`${PLUGIN_IDENTIFIER} mfConfig.name can not be empty!`);
+    const runtimePlugins = [
+        ...mfConfig.runtimePlugins || []
+    ];
+    patchDTSConfig(mfConfig, isServer);
+    injectRuntimePlugins(resolveSharedStrategyPlugin(), runtimePlugins);
+    if (isServer) {
+        injectRuntimePlugins(resolveNodeRuntimePlugin(), runtimePlugins);
+        if (isDev()) injectRuntimePlugins(resolveNodeRecordRemoteHashPlugin(), runtimePlugins);
+        injectRuntimePlugins(resolveInjectNodeFetchPlugin(), runtimePlugins);
+        if (mfConfig.library) {
+            if (!mfConfig.library.type) mfConfig.library.type = 'commonjs-module';
+            if (!mfConfig.library.name) mfConfig.library.name = mfConfig.name;
+        } else mfConfig.library = {
+            type: 'commonjs-module',
+            name: mfConfig.name
+        };
+    }
+    mfConfig.runtimePlugins = runtimePlugins;
+    if (!isServer) {
+        var _mfConfig_library;
+        if ((null == (_mfConfig_library = mfConfig.library) ? void 0 : _mfConfig_library.type) === 'commonjs-module') mfConfig.library.type = 'global';
+        return mfConfig;
+    }
+    mfConfig.dts = false;
+    mfConfig.dev = false;
+    return mfConfig;
+};
+function patchIgnoreWarning(chain) {
+    const ignoreWarnings = chain.get('ignoreWarnings') || [];
+    const ignoredMsgs = [
+        "external script",
+        'process.env.WS_NO_BUFFER_UTIL',
+        "Can't resolve 'utf-8-validate"
+    ];
+    ignoreWarnings.push((warning)=>{
+        if (ignoredMsgs.some((msg)=>warning.message.includes(msg))) return true;
+        return false;
+    });
+    chain.ignoreWarnings(ignoreWarnings);
+}
+function addMyTypes2Ignored(chain, mfConfig) {
+    const watchOptions = chain.get('watchOptions');
+    if (!watchOptions || !watchOptions.ignored) return void chain.watchOptions({
+        ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    });
+    const ignored = watchOptions.ignored;
+    const DEFAULT_IGNORED_GLOB = '**/@mf-types/**';
+    if (Array.isArray(ignored)) {
+        if (false !== mfConfig.dts && 'object' == typeof mfConfig.dts && 'object' == typeof mfConfig.dts.consumeTypes && mfConfig.dts.consumeTypes.remoteTypesFolder) chain.watchOptions({
+            ...watchOptions,
+            ignored: ignored.concat(`**/${mfConfig.dts.consumeTypes.remoteTypesFolder}/**`)
+        });
+        else chain.watchOptions({
+            ...watchOptions,
+            ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+        });
+        return;
+    }
+    if ('string' != typeof ignored) return void chain.watchOptions({
+        ...watchOptions,
+        ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    });
+    chain.watchOptions({
+        ...watchOptions,
+        ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+    });
+}
+function patchBundlerConfig(options) {
+    var _modernjsConfig_deploy;
+    const { chain, modernjsConfig, isServer, mfConfig, enableSSR } = options;
+    chain.optimization.delete('runtimeChunk');
+    patchIgnoreWarning(chain);
+    if (!chain.output.get('chunkLoadingGlobal')) chain.output.chunkLoadingGlobal(`chunk_${mfConfig.name}`);
+    if (!chain.output.get('uniqueName')) chain.output.uniqueName(mfConfig.name);
+    const splitChunkConfig = chain.optimization.splitChunks.entries();
+    if (!isServer) autoDeleteSplitChunkCacheGroups(mfConfig, splitChunkConfig);
+    if (!isServer && enableSSR && splitChunkConfig && 'object' == typeof splitChunkConfig && splitChunkConfig.cacheGroups) {
+        splitChunkConfig.chunks = 'async';
+        logger.warn('splitChunks.chunks = async is not allowed with stream SSR mode, it will auto changed to "async"');
+    }
+    if (isDev() && 'auto' === chain.output.get('publicPath')) {
+        var _modernjsConfig_dev, _modernjsConfig_server;
+        const port = (null == (_modernjsConfig_dev = modernjsConfig.dev) ? void 0 : _modernjsConfig_dev.port) || (null == (_modernjsConfig_server = modernjsConfig.server) ? void 0 : _modernjsConfig_server.port) || 8080;
+        const publicPath = `http://localhost:${port}/`;
+        chain.output.publicPath(publicPath);
+    }
+    if (isServer && enableSSR) {
+        const uniqueName = mfConfig.name || chain.output.get('uniqueName');
+        const chunkFileName = chain.output.get('chunkFilename');
+        if ('string' == typeof chunkFileName && uniqueName && !chunkFileName.includes(uniqueName)) {
+            const suffix = `${encodeName(uniqueName)}-[contenthash].js`;
+            chain.output.chunkFilename(chunkFileName.replace('.js', suffix));
+        }
+    }
+    if (isDev() && enableSSR && !isServer) chain.resolve.fallback.set('crypto', false).set('stream', false).set('vm', false);
+    if ((null == (_modernjsConfig_deploy = modernjsConfig.deploy) ? void 0 : _modernjsConfig_deploy.microFrontend) && Object.keys(mfConfig.exposes || {}).length) chain.optimization.usedExports(false);
+}
+const moduleFederationConfigPlugin = (userConfig)=>({
+        name: '@modern-js/plugin-module-federation-config',
+        pre: [
+            '@modern-js/plugin-initialize'
+        ],
+        post: [
+            '@modern-js/plugin-module-federation'
+        ],
+        setup: async (api)=>{
+            var _ref;
+            var _userConfig_userConfig, _modernjsConfig_server;
+            const modernjsConfig = api.getConfig();
+            const mfConfig = await getMFConfig(userConfig.originPluginOptions);
+            const csrConfig = userConfig.csrConfig || JSON.parse(JSON.stringify(mfConfig));
+            const ssrConfig = userConfig.ssrConfig || JSON.parse(JSON.stringify(mfConfig));
+            userConfig.ssrConfig = ssrConfig;
+            userConfig.csrConfig = csrConfig;
+            const enableSSR = Boolean(null != (_ref = null == (_userConfig_userConfig = userConfig.userConfig) ? void 0 : _userConfig_userConfig.ssr) ? _ref : Boolean(null == modernjsConfig ? void 0 : null == (_modernjsConfig_server = modernjsConfig.server) ? void 0 : _modernjsConfig_server.ssr));
+            api.modifyBundlerChain((chain)=>{
+                var _modernjsConfig_source, _targetMFConfig_experiments;
+                const bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                const target = chain.get('target');
+                if (skipByTarget(target)) return;
+                const isWeb = isWebTarget(target);
+                addMyTypes2Ignored(chain, isWeb ? csrConfig : ssrConfig);
+                const targetMFConfig = isWeb ? csrConfig : ssrConfig;
+                patchMFConfig(targetMFConfig, !isWeb);
+                if ('rspack' === bundlerType && (null == (_modernjsConfig_source = modernjsConfig.source) ? void 0 : _modernjsConfig_source.enableAsyncEntry) !== true && (null == (_targetMFConfig_experiments = targetMFConfig.experiments) ? void 0 : _targetMFConfig_experiments.asyncStartup) !== false) {
+                    var _targetMFConfig;
+                    (_targetMFConfig = targetMFConfig).experiments || (_targetMFConfig.experiments = {});
+                    targetMFConfig.experiments.asyncStartup = true;
+                }
+                patchBundlerConfig({
+                    chain,
+                    isServer: !isWeb,
+                    modernjsConfig,
+                    mfConfig,
+                    enableSSR
+                });
+                if (isWeb) userConfig.distOutputDir = chain.output.get('path') || path.resolve(process.cwd(), 'dist');
+                else if (enableSSR) {
+                    var _userConfig, _userConfig_userConfig;
+                    (_userConfig = userConfig).userConfig || (_userConfig.userConfig = {});
+                    (_userConfig_userConfig = userConfig.userConfig).ssr || (_userConfig_userConfig.ssr = {});
+                    if (true === userConfig.userConfig.ssr) userConfig.userConfig.ssr = {};
+                    userConfig.userConfig.ssr.distOutputDir = chain.output.get('path') || path.resolve(process.cwd(), 'dist/bundles');
+                }
+            });
+            api.config(()=>{
+                var _ref;
+                var _modernjsConfig_tools, _userConfig_csrConfig, _modernjsConfig_source, _modernjsConfig_source1, _modernjsConfig_dev;
+                const bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                const devServerConfig = null == (_modernjsConfig_tools = modernjsConfig.tools) ? void 0 : _modernjsConfig_tools.devServer;
+                const corsWarnMsgs = [
+                    'View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details.'
+                ];
+                if ('object' != typeof devServerConfig || !('headers' in devServerConfig)) corsWarnMsgs.unshift('Detect devServer.headers is empty, mf modern plugin will add default cors header: devServer.headers["Access-Control-Allow-Headers"] = "*". It is recommended to specify an allowlist of trusted origins instead.');
+                const exposes = null == (_userConfig_csrConfig = userConfig.csrConfig) ? void 0 : _userConfig_csrConfig.exposes;
+                const hasExposes = exposes && Array.isArray(exposes) ? exposes.length : Object.keys(null != exposes ? exposes : {}).length;
+                if (corsWarnMsgs.length > 1 && hasExposes) logger.warn(corsWarnMsgs.join('\n'));
+                const corsHeaders = hasExposes ? {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
+                    'Access-Control-Allow-Headers': '*'
+                } : void 0;
+                return {
+                    tools: {
+                        devServer: {
+                            headers: corsHeaders
+                        }
+                    },
+                    resolve: {
+                        alias: {
+                            '@modern-js/runtime/mf': require.resolve('@module-federation/modern-js/runtime')
+                        }
+                    },
+                    source: {
+                        enableAsyncEntry: 'rspack' === bundlerType ? null != (_ref = null == (_modernjsConfig_source = modernjsConfig.source) ? void 0 : _modernjsConfig_source.enableAsyncEntry) ? _ref : true : null == (_modernjsConfig_source1 = modernjsConfig.source) ? void 0 : _modernjsConfig_source1.enableAsyncEntry
+                    },
+                    dev: {
+                        assetPrefix: (null == modernjsConfig ? void 0 : null == (_modernjsConfig_dev = modernjsConfig.dev) ? void 0 : _modernjsConfig_dev.assetPrefix) ? modernjsConfig.dev.assetPrefix : true
+                    }
+                };
+            });
+        }
+    });
+const configPlugin = moduleFederationConfigPlugin;
+export { addMyTypes2Ignored, configPlugin as default, getMFConfig, isWebTarget, moduleFederationConfigPlugin, patchBundlerConfig, patchMFConfig, setEnv, skipByTarget };

package/dist/esm-node/cli/index.mjs

@@ -0,0 +1,75 @@
+import { AsyncBoundaryPlugin, ModuleFederationPlugin, TreeShakingSharedPlugin as enhanced_TreeShakingSharedPlugin, createModuleFederationConfig } from "@module-federation/enhanced";
+import { ModuleFederationPlugin as rspack_ModuleFederationPlugin, TreeShakingSharedPlugin as rspack_TreeShakingSharedPlugin } from "@module-federation/enhanced/rspack";
+import { moduleFederationConfigPlugin } from "./configPlugin.mjs";
+import { moduleFederationSSRPlugin } from "./ssrPlugin.mjs";
+import { isWebTarget } from "./utils.mjs";
+const moduleFederationPlugin = (userConfig = {})=>{
+    var _userConfig_fetchServerQuery, _userConfig_secondarySharedTreeShaking;
+    const internalModernPluginOptions = {
+        csrConfig: void 0,
+        ssrConfig: void 0,
+        browserPlugin: void 0,
+        nodePlugin: void 0,
+        assetResources: {},
+        distOutputDir: '',
+        originPluginOptions: {
+            ...userConfig
+        },
+        userConfig: userConfig || {},
+        assetFileNames: {},
+        fetchServerQuery: null != (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) ? _userConfig_fetchServerQuery : void 0,
+        secondarySharedTreeShaking: null != (_userConfig_secondarySharedTreeShaking = userConfig.secondarySharedTreeShaking) ? _userConfig_secondarySharedTreeShaking : false
+    };
+    return {
+        name: '@modern-js/plugin-module-federation',
+        setup: async (api)=>{
+            const modernjsConfig = api.getConfig();
+            api.modifyBundlerChain((chain)=>{
+                const bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                const browserPluginOptions = internalModernPluginOptions.csrConfig;
+                const { secondarySharedTreeShaking } = internalModernPluginOptions;
+                const MFPlugin = 'webpack' === bundlerType ? ModuleFederationPlugin : rspack_ModuleFederationPlugin;
+                const TreeShakingSharedPlugin = 'webpack' === bundlerType ? enhanced_TreeShakingSharedPlugin : rspack_TreeShakingSharedPlugin;
+                if (isWebTarget(chain.get('target'))) if (secondarySharedTreeShaking) chain.plugin('plugin-module-federation').use(TreeShakingSharedPlugin, [
+                    {
+                        mfConfig: browserPluginOptions,
+                        secondary: true
+                    }
+                ]);
+                else chain.plugin('plugin-module-federation').use(MFPlugin, [
+                    browserPluginOptions
+                ]).init((Plugin, args)=>{
+                    internalModernPluginOptions.browserPlugin = new Plugin(args[0]);
+                    return internalModernPluginOptions.browserPlugin;
+                });
+                if ('webpack' === bundlerType && !secondarySharedTreeShaking) {
+                    var _modernjsConfig_source;
+                    const enableAsyncEntry = null == (_modernjsConfig_source = modernjsConfig.source) ? void 0 : _modernjsConfig_source.enableAsyncEntry;
+                    if (!enableAsyncEntry && false !== browserPluginOptions.async) {
+                        const asyncBoundaryPluginOptions = 'object' == typeof browserPluginOptions.async ? browserPluginOptions.async : {
+                            eager: (module)=>module && /\.federation/.test((null == module ? void 0 : module.request) || ''),
+                            excludeChunk: (chunk)=>chunk.name === browserPluginOptions.name
+                        };
+                        chain.plugin('async-boundary-plugin').use(AsyncBoundaryPlugin, [
+                            asyncBoundaryPluginOptions
+                        ]);
+                    }
+                }
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                plugins.push({
+                    name: '@module-federation/modern-js/server'
+                });
+                return {
+                    plugins
+                };
+            });
+        },
+        usePlugins: [
+            moduleFederationConfigPlugin(internalModernPluginOptions),
+            moduleFederationSSRPlugin(internalModernPluginOptions)
+        ]
+    };
+};
+const cli = moduleFederationPlugin;
+export { createModuleFederationConfig, cli as default, moduleFederationPlugin };

package/dist/esm-node/cli/mfRuntimePlugins/inject-node-fetch.mjs

@@ -0,0 +1,10 @@
+import node_fetch from "node-fetch";
+const injectNodeFetchPlugin = ()=>({
+        name: 'inject-node-fetch-plugin',
+        beforeInit (args) {
+            if (!globalThis.fetch) globalThis.fetch = node_fetch;
+            return args;
+        }
+    });
+const inject_node_fetch = injectNodeFetchPlugin;
+export { inject_node_fetch as default };

package/dist/esm-node/cli/mfRuntimePlugins/shared-strategy.mjs

@@ -0,0 +1,19 @@
+const sharedStrategy = ()=>({
+        name: 'shared-strategy-plugin',
+        beforeInit (args) {
+            const { userOptions } = args;
+            const shared = userOptions.shared;
+            if (shared) Object.keys(shared).forEach((sharedKey)=>{
+                const sharedConfigs = shared[sharedKey];
+                const arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [
+                    sharedConfigs
+                ];
+                arraySharedConfigs.forEach((s)=>{
+                    s.strategy = 'loaded-first';
+                });
+            });
+            return args;
+        }
+    });
+const shared_strategy = sharedStrategy;
+export { shared_strategy as default };

package/dist/esm-node/cli/server/data-fetch-server-plugin.mjs

@@ -0,0 +1,15 @@
+import data_fetch_server_middleware from "@module-federation/bridge-react/data-fetch-server-middleware";
+const dataFetchServePlugin = ()=>({
+        name: 'mf-data-fetch-server-plugin',
+        setup: (api)=>{
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'module-federation-serve-manifest',
+                    handler: data_fetch_server_middleware
+                });
+            });
+        }
+    });
+const data_fetch_server_plugin = dataFetchServePlugin;
+export { data_fetch_server_plugin as default };