@module-federation/rsbuild-plugin 0.19.0 → 0.20.0

package/dist/utils.mjs

@@ -0,0 +1,186 @@
+import util from "util";
+import fs_extra from "fs-extra";
+import path from "path";
+import { TEMP_DIR, encodeName } from "@module-federation/sdk";
+import { createRequire } from "node:module";
+const DATA_FETCH_CLIENT_SUFFIX = '.client';
+const CALL_NAME_MAP = {
+    RSPRESS: 'rspress',
+    RSLIB: 'rslib'
+};
+const SPLIT_CHUNK_MAP = {
+    REACT: 'react',
+    ROUTER: 'router',
+    LODASH: 'lib-lodash',
+    ANTD: 'lib-antd',
+    ARCO: 'lib-arco',
+    SEMI: 'lib-semi',
+    AXIOS: 'lib-axios'
+};
+const SHARED_SPLIT_CHUNK_MAP = {
+    react: SPLIT_CHUNK_MAP.REACT,
+    'react-dom': SPLIT_CHUNK_MAP.REACT,
+    'react-router': SPLIT_CHUNK_MAP.ROUTER,
+    'react-router-dom': SPLIT_CHUNK_MAP.ROUTER,
+    '@remix-run/router': SPLIT_CHUNK_MAP.ROUTER,
+    lodash: SPLIT_CHUNK_MAP.LODASH,
+    'lodash-es': SPLIT_CHUNK_MAP.LODASH,
+    antd: SPLIT_CHUNK_MAP.ANTD,
+    '@arco-design/web-react': SPLIT_CHUNK_MAP.ARCO,
+    '@douyinfe/semi-ui': SPLIT_CHUNK_MAP.SEMI,
+    axios: SPLIT_CHUNK_MAP.AXIOS
+};
+function autoDeleteSplitChunkCacheGroups(mfConfig, splitChunks) {
+    if (!mfConfig.shared) return;
+    if (!splitChunks || !(null == splitChunks ? void 0 : splitChunks.cacheGroups)) return;
+    const arrayShared = Array.isArray(mfConfig.shared) ? mfConfig.shared : Object.keys(mfConfig.shared);
+    for (const shared of arrayShared){
+        const splitChunkKey = SHARED_SPLIT_CHUNK_MAP[shared];
+        if (splitChunkKey) {
+            if (splitChunks.cacheGroups[splitChunkKey]) delete splitChunks.cacheGroups[splitChunkKey];
+        }
+    }
+    return splitChunks;
+}
+const addDataFetchExpose = (exposes, key, filepath, suffix = '')=>{
+    if (!fs_extra.existsSync(filepath)) return false;
+    const dataFetchKey = '.' === key ? `./data${suffix}` : `${key}.data${suffix}`;
+    if (exposes[dataFetchKey] && exposes[dataFetchKey] !== filepath) throw new Error(`data fetch key ${dataFetchKey} already exists, please modify this expose key, do not end with 'data' or '${DATA_FETCH_CLIENT_SUFFIX}'`);
+    exposes[dataFetchKey] = filepath;
+    return dataFetchKey;
+};
+const addExcludeDtsSuffix = (filepath)=>`${filepath}?exclude-mf-dts=true`;
+function addDataFetchExposes(exposes, isServer) {
+    if ('object' != typeof exposes || Array.isArray(exposes)) return;
+    if (0 === Object.keys(exposes).length) return;
+    const tempDataFetchFilepath = path.resolve(process.cwd(), `node_modules/${TEMP_DIR}/data-fetch-fallback.ts`);
+    const content = "export const fetchData=()=>{throw new Error('should not be called')};";
+    fs_extra.ensureDirSync(path.dirname(tempDataFetchFilepath));
+    fs_extra.writeFileSync(tempDataFetchFilepath, content);
+    Object.keys(exposes).forEach((key)=>{
+        const expose = exposes[key];
+        if ('string' != typeof expose) return;
+        const absPath = path.resolve(process.cwd(), expose);
+        const dataFetchPath = `${absPath.replace(path.extname(absPath), '')}.data.ts`;
+        const dataFetchClientPath = `${absPath.replace(path.extname(absPath), '')}.data.client.ts`;
+        const dateFetchClientKey = addDataFetchExpose(exposes, key, dataFetchClientPath, DATA_FETCH_CLIENT_SUFFIX);
+        if (!isServer && dateFetchClientKey) {
+            exposes[dateFetchClientKey.replace(DATA_FETCH_CLIENT_SUFFIX, '')] = addExcludeDtsSuffix(tempDataFetchFilepath);
+            return;
+        }
+        const dataFetchKey = addDataFetchExpose(exposes, key, dataFetchPath);
+        if (dataFetchKey && fs_extra.existsSync(dataFetchClientPath)) exposes[`${dataFetchKey}${DATA_FETCH_CLIENT_SUFFIX}`] = addExcludeDtsSuffix(tempDataFetchFilepath);
+    });
+}
+function mergeStats(browserStats, nodeStats) {
+    const ssrRemoteEntry = nodeStats.metaData.remoteEntry;
+    browserStats.metaData.ssrRemoteEntry = ssrRemoteEntry;
+    if ('publicPath' in browserStats.metaData) browserStats.metaData.ssrPublicPath = nodeStats.metaData.publicPath;
+    return browserStats;
+}
+function mergeManifest(browserManifest, nodeManifest) {
+    const ssrRemoteEntry = nodeManifest.metaData.remoteEntry;
+    browserManifest.metaData.ssrRemoteEntry = ssrRemoteEntry;
+    if ('publicPath' in browserManifest.metaData) browserManifest.metaData.ssrPublicPath = nodeManifest.metaData.publicPath;
+    return browserManifest;
+}
+function mergeStatsAndManifest(nodePlugin, browserPlugin) {
+    const nodeResourceInfo = nodePlugin.statsResourceInfo;
+    const browserResourceInfo = browserPlugin.statsResourceInfo;
+    if (!browserResourceInfo || !nodeResourceInfo || !browserResourceInfo.stats || !nodeResourceInfo.stats || !browserResourceInfo.manifest || !nodeResourceInfo.manifest) throw new Error('can not get browserResourceInfo or nodeResourceInfo');
+    const mergedStats = mergeStats(browserResourceInfo.stats.stats, nodeResourceInfo.stats.stats);
+    const mergedManifest = mergeManifest(browserResourceInfo.manifest.manifest, nodeResourceInfo.manifest.manifest);
+    return {
+        mergedStats: mergedStats,
+        mergedStatsFilePath: browserResourceInfo.stats.filename,
+        mergedManifest: mergedManifest,
+        mergedManifestFilePath: browserResourceInfo.manifest.filename
+    };
+}
+function updateStatsAndManifest(nodePlugin, browserPlugin, outputDir) {
+    const { mergedStats, mergedStatsFilePath, mergedManifest, mergedManifestFilePath } = mergeStatsAndManifest(nodePlugin, browserPlugin);
+    fs_extra.writeFileSync(path.resolve(outputDir, mergedStatsFilePath), JSON.stringify(mergedStats, null, 2));
+    fs_extra.writeFileSync(path.resolve(outputDir, mergedManifestFilePath), JSON.stringify(mergedManifest, null, 2));
+}
+const ssr_require = createRequire(import.meta.url);
+const resolve = ssr_require.resolve;
+const SSR_DIR = 'ssr';
+const SSR_ENV_NAME = 'mf-ssr';
+function setSSREnv() {
+    process.env['MF_DISABLE_EMIT_STATS'] = 'true';
+    process.env['MF_SSR_PRJ'] = 'true';
+}
+const isDev = ()=>'development' === process.env['NODE_ENV'];
+function patchSSRRspackConfig(config, mfConfig, ssrDir, callerName, resetEntry = true, modifyPublicPath = true) {
+    var _config_output;
+    config.output ||= {};
+    if (modifyPublicPath) {
+        var _config_output1;
+        if ('string' != typeof (null == (_config_output1 = config.output) ? void 0 : _config_output1.publicPath)) throw new Error('publicPath must be string!');
+        const publicPath = config.output.publicPath;
+        if ('auto' === publicPath) throw new Error('publicPath can not be "auto"!');
+        const publicPathWithSSRDir = `${publicPath}${ssrDir}/`;
+        config.output.publicPath = publicPathWithSSRDir;
+    }
+    if (callerName === CALL_NAME_MAP.RSPRESS && resetEntry) config.entry = 'data:application/node;base64,';
+    config.target = 'async-node';
+    const UniverseEntryChunkTrackerPlugin = ssr_require('@module-federation/node/universe-entry-chunk-tracker-plugin').default;
+    config.plugins ||= [];
+    isDev() && config.plugins.push(new UniverseEntryChunkTrackerPlugin());
+    const uniqueName = mfConfig.name || (null == (_config_output = config.output) ? void 0 : _config_output.uniqueName);
+    const chunkFileName = config.output.chunkFilename;
+    if ('string' == typeof chunkFileName && uniqueName && !chunkFileName.includes(uniqueName)) {
+        const suffix = `${encodeName(uniqueName)}-[contenthash].js`;
+        config.output.chunkFilename = chunkFileName.replace('.js', suffix);
+    }
+    return config;
+}
+function createSSRREnvConfig(envConfig, mfConfig, ssrDir, rsbuildConfig, callerName) {
+    var _ssrEnvConfig_output, _ssrEnvConfig_output_distPath, _ssrEnvConfig_output1, _rsbuildConfig_output_distPath, _rsbuildConfig_output;
+    const ssrEnvConfig = {
+        ...envConfig,
+        tools: {
+            rspack: (config, { environment })=>{
+                if (environment.name !== SSR_ENV_NAME) return;
+                patchSSRRspackConfig(config, mfConfig, ssrDir, callerName);
+            }
+        }
+    };
+    ssrEnvConfig.output = {
+        ...ssrEnvConfig.output,
+        target: 'node',
+        distPath: {
+            ...null == (_ssrEnvConfig_output = ssrEnvConfig.output) ? void 0 : _ssrEnvConfig_output.distPath,
+            root: path.join((null == (_ssrEnvConfig_output1 = ssrEnvConfig.output) ? void 0 : null == (_ssrEnvConfig_output_distPath = _ssrEnvConfig_output1.distPath) ? void 0 : _ssrEnvConfig_output_distPath.root) || (null == (_rsbuildConfig_output = rsbuildConfig.output) ? void 0 : null == (_rsbuildConfig_output_distPath = _rsbuildConfig_output.distPath) ? void 0 : _rsbuildConfig_output_distPath.root) || '', ssrDir)
+        },
+        emitAssets: true
+    };
+    return ssrEnvConfig;
+}
+function createSSRMFConfig(mfConfig) {
+    var _mfConfig_library;
+    const ssrMFConfig = {
+        ...mfConfig,
+        exposes: {
+            ...mfConfig.exposes
+        },
+        library: {
+            ...mfConfig.library,
+            name: mfConfig.name,
+            type: (null == (_mfConfig_library = mfConfig.library) ? void 0 : _mfConfig_library.type) ?? 'commonjs-module'
+        },
+        dts: false,
+        dev: false,
+        runtimePlugins: [
+            ...mfConfig.runtimePlugins || []
+        ]
+    };
+    ssrMFConfig.runtimePlugins.push(resolve('@module-federation/node/runtimePlugin'));
+    if (isDev()) ssrMFConfig.runtimePlugins.push(resolve('@module-federation/node/record-dynamic-remote-entry-hash-plugin'));
+    return ssrMFConfig;
+}
+function isRegExp(target) {
+    return util.types.isRegExp(target);
+}
+var __webpack_exports__DEFAULT_ASSET_PREFIX = "/";
+export { SSR_DIR, SSR_ENV_NAME, addDataFetchExposes, autoDeleteSplitChunkCacheGroups, createSSRMFConfig, createSSRREnvConfig, isRegExp, patchSSRRspackConfig, setSSREnv, updateStatsAndManifest, __webpack_exports__DEFAULT_ASSET_PREFIX as DEFAULT_ASSET_PREFIX };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/rsbuild-plugin",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Module Federation plugin for Rsbuild",
   "homepage": "https://module-federation.io",
   "bugs": {
@@ -14,31 +14,31 @@
   "license": "MIT",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.esm.mjs",
-      "require": "./dist/index.cjs.js"
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     },
     "./utils": {
-      "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.esm.mjs",
-      "require": "./dist/utils.cjs.js"
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.js"
     },
     "./constant": {
       "types": "./dist/constant.d.ts",
-      "import": "./dist/constant.esm.mjs",
-      "require": "./dist/constant.cjs.js"
+      "import": "./dist/constant.mjs",
+      "require": "./dist/constant.js"
     }
   },
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.esm.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/cli/index.d.ts",
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
+        "./dist/cli/index.d.ts"
       ],
       "utils": [
-        "./dist/utils.d.ts"
+        "./dist/utils/index.d.ts"
       ],
       "constant": [
         "./dist/constant.d.ts"
@@ -50,11 +50,12 @@
   ],
   "dependencies": {
     "fs-extra": "11.3.0",
-    "@module-federation/sdk": "0.19.0",
-    "@module-federation/enhanced": "0.19.0",
-    "@module-federation/node": "2.7.16"
+    "@module-federation/enhanced": "0.20.0",
+    "@module-federation/node": "2.7.18",
+    "@module-federation/sdk": "0.20.0"
   },
   "devDependencies": {
+    "@rslib/core": "^0.12.4",
     "@rsbuild/core": "^1.3.21"
   },
   "peerDependencies": {

package/dist/constant.cjs.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var DEFAULT_ASSET_PREFIX = '/';
-var DATA_FETCH_IDENTIFIER = 'data';
-var DATA_FETCH_CLIENT_SUFFIX = '.client';
-var CALL_NAME_MAP = {
-    RSPRESS: 'rspress',
-    RSLIB: 'rslib'
-};
-var RSPRESS_BUNDLER_CONFIG_NAME = 'node';
-var RSPRESS_SSR_DIR = 'ssr';
-
-exports.CALL_NAME_MAP = CALL_NAME_MAP;
-exports.DATA_FETCH_CLIENT_SUFFIX = DATA_FETCH_CLIENT_SUFFIX;
-exports.DATA_FETCH_IDENTIFIER = DATA_FETCH_IDENTIFIER;
-exports.DEFAULT_ASSET_PREFIX = DEFAULT_ASSET_PREFIX;
-exports.RSPRESS_BUNDLER_CONFIG_NAME = RSPRESS_BUNDLER_CONFIG_NAME;
-exports.RSPRESS_SSR_DIR = RSPRESS_SSR_DIR;
-//# sourceMappingURL=constant.cjs.js.map

package/dist/constant.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constant.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/dist/constant.esm.d.ts

@@ -1 +0,0 @@
-export * from "./src/constant";

package/dist/constant.esm.mjs

@@ -1,12 +0,0 @@
-var DEFAULT_ASSET_PREFIX = '/';
-var DATA_FETCH_IDENTIFIER = 'data';
-var DATA_FETCH_CLIENT_SUFFIX = '.client';
-var CALL_NAME_MAP = {
-    RSPRESS: 'rspress',
-    RSLIB: 'rslib'
-};
-var RSPRESS_BUNDLER_CONFIG_NAME = 'node';
-var RSPRESS_SSR_DIR = 'ssr';
-
-export { CALL_NAME_MAP, DATA_FETCH_CLIENT_SUFFIX, DATA_FETCH_IDENTIFIER, DEFAULT_ASSET_PREFIX, RSPRESS_BUNDLER_CONFIG_NAME, RSPRESS_SSR_DIR };
-//# sourceMappingURL=constant.esm.mjs.map

package/dist/constant.esm.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constant.esm.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/dist/index.cjs.js

@@ -1,360 +0,0 @@
-'use strict';
-
-var enhanced = require('@module-federation/enhanced');
-var rspack = require('@module-federation/enhanced/rspack');
-var sdk = require('@module-federation/sdk');
-var utils = require('./utils.cjs.js');
-var constant = require('./constant.cjs.js');
-require('util');
-require('fs-extra');
-require('path');
-require('node:module');
-
-var name = "@module-federation/rsbuild-plugin";
-var pkgJson = {
-    name: name};
-
-var logger = sdk.createLogger('[ Module Federation Rsbuild Plugin ]');
-
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-var RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = 'rsbuild:module-federation-enhanced';
-var RSBUILD_PLUGIN_NAME = '@module-federation/rsbuild-plugin';
-var LIB_FORMAT = [
-    'umd',
-    'modern-module'
-];
-var DEFAULT_MF_ENVIRONMENT_NAME = 'mf';
-function isStoryBook(rsbuildConfig) {
-    var _rsbuildConfig_plugins;
-    if ((_rsbuildConfig_plugins = rsbuildConfig.plugins) === null || _rsbuildConfig_plugins === void 0 ? void 0 : _rsbuildConfig_plugins.find(function(p) {
-        return p && 'name' in p && p.name === 'module-federation-storybook-plugin';
-    })) {
-        return true;
-    }
-    return false;
-}
-function isMFFormat(bundlerConfig) {
-    var _bundlerConfig_output;
-    var library = (_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.library;
-    if (bundlerConfig.name === utils.SSR_ENV_NAME) {
-        return true;
-    }
-    return !((typeof library === "undefined" ? "undefined" : _type_of(library)) === 'object' && !Array.isArray(library) && 'type' in library && (LIB_FORMAT.includes(library.type) || /commonjs/.test(library.type)));
-}
-var isSSRConfig = function(bundlerConfigName) {
-    return Boolean(bundlerConfigName === utils.SSR_ENV_NAME);
-};
-var isRspressSSGConfig = function(bundlerConfigName) {
-    return bundlerConfigName === constant.RSPRESS_BUNDLER_CONFIG_NAME;
-};
-var pluginModuleFederation = function(moduleFederationOptions, rsbuildOptions) {
-    return {
-        name: RSBUILD_PLUGIN_MODULE_FEDERATION_NAME,
-        setup: function(api) {
-            var _ref = rsbuildOptions || {}, _ref_ssr = _ref.ssr, ssr = _ref_ssr === void 0 ? undefined : _ref_ssr, _ref_ssrDir = _ref.ssrDir, ssrDir = _ref_ssrDir === void 0 ? utils.SSR_DIR : _ref_ssrDir, _ref_environment = _ref.environment, environment = _ref_environment === void 0 ? DEFAULT_MF_ENVIRONMENT_NAME : _ref_environment;
-            var callerName = api.context.callerName;
-            var originalRsbuildConfig = api.getRsbuildConfig();
-            if (!callerName) {
-                throw new Error('`callerName` is undefined. Please ensure the @rsbuild/core version is higher than 1.3.21 .');
-            }
-            var isRslib = callerName === constant.CALL_NAME_MAP.RSLIB;
-            var isRspress = callerName === constant.CALL_NAME_MAP.RSPRESS;
-            var isSSR = Boolean(ssr);
-            if (isSSR && !isStoryBook(originalRsbuildConfig)) {
-                var _rsbuildConfig_environments;
-                if (!isRslib && !isRspress) {
-                    throw new Error("'ssr' option is only supported in rslib.");
-                }
-                var rsbuildConfig = api.getRsbuildConfig();
-                if (!((_rsbuildConfig_environments = rsbuildConfig.environments) === null || _rsbuildConfig_environments === void 0 ? void 0 : _rsbuildConfig_environments[environment]) || Object.keys(rsbuildConfig.environments).some(function(key) {
-                    return key.startsWith(environment) && key !== environment;
-                })) {
-                    throw new Error("Please set ".concat(RSBUILD_PLUGIN_NAME, " as global plugin in rslib.config.ts if you set 'ssr:true' ."));
-                }
-                utils.setSSREnv();
-            }
-            var sharedOptions = enhanced.parseOptions(moduleFederationOptions.shared || [], function(item, key) {
-                if (typeof item !== 'string') throw new Error('Unexpected array in shared');
-                var config = item === key || !sdk.isRequiredVersion(item) ? {
-                    import: item
-                } : {
-                    import: key,
-                    requiredVersion: item
-                };
-                return config;
-            }, function(item, key) {
-                return item;
-            });
-            var shared = sharedOptions.map(function(shared) {
-                return shared[0].endsWith('/') ? shared[0].slice(0, -1) : shared[0];
-            });
-            api.modifyRsbuildConfig(function(config) {
-                if (isStoryBook(config)) {
-                    return;
-                }
-                if (moduleFederationOptions.exposes) {
-                    var _userConfig_server, _config_server, _config_dev_client, _originalConfig_dev, _config_server1;
-                    var _config, _config1, _config_server2;
-                    (_config = config).dev || (_config.dev = {});
-                    (_config1 = config).server || (_config1.server = {});
-                    var userConfig = api.getRsbuildConfig('original');
-                    (_config_server2 = config.server).headers || (_config_server2.headers = {});
-                    if (!config.server.headers['Access-Control-Allow-Origin'] && !(_type_of((_userConfig_server = userConfig.server) === null || _userConfig_server === void 0 ? void 0 : _userConfig_server.cors) === 'object' && userConfig.server.cors.origin)) {
-                        var corsWarnMsgs = [
-                            'Detect that CORS options are not set, mf Rsbuild plugin will add default cors header: server.headers["Access-Control-Allow-Headers"] = "*". It is recommended to specify an allowlist of trusted origins in "server.cors" instead.',
-                            'View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details.'
-                        ];
-                        !isRslib && !isRspress && logger.warn(corsWarnMsgs.join('\n'));
-                        config.server.headers['Access-Control-Allow-Origin'] = '*';
-                    }
-                    if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.port) && !((_config_dev_client = config.dev.client) === null || _config_dev_client === void 0 ? void 0 : _config_dev_client.port)) {
-                        var _config_dev;
-                        (_config_dev = config.dev).client || (_config_dev.client = {});
-                        config.dev.client.port = config.server.port;
-                    }
-                    var originalConfig = api.getRsbuildConfig('original');
-                    if (((_originalConfig_dev = originalConfig.dev) === null || _originalConfig_dev === void 0 ? void 0 : _originalConfig_dev.assetPrefix) === undefined && config.dev.assetPrefix === ((_config_server1 = config.server) === null || _config_server1 === void 0 ? void 0 : _config_server1.base)) {
-                        config.dev.assetPrefix = true;
-                    }
-                }
-                if (isSSR) {
-                    var _config_environments, _config_environments1;
-                    if ((_config_environments = config.environments) === null || _config_environments === void 0 ? void 0 : _config_environments[utils.SSR_ENV_NAME]) {
-                        throw new Error("'".concat(utils.SSR_ENV_NAME, "' environment is already defined. Please use another name."));
-                    }
-                    config.environments[utils.SSR_ENV_NAME] = utils.createSSRREnvConfig((_config_environments1 = config.environments) === null || _config_environments1 === void 0 ? void 0 : _config_environments1[environment], moduleFederationOptions, ssrDir, config, callerName);
-                }
-            });
-            api.modifyEnvironmentConfig(function(config) {
-                config.source.include = _to_consumable_array(config.source.include || []).concat([
-                    /@module-federation\/webpack-bundler-runtime/,
-                    /@module-federation\/runtime/,
-                    /@module-federation\/runtime-core/,
-                    /@module-federation\/sdk/
-                ]);
-                return config;
-            });
-            var generateMergedStatsAndManifestOptions = {
-                options: {
-                    nodePlugin: undefined,
-                    browserPlugin: undefined,
-                    distOutputDir: undefined
-                },
-                isSSRConfig: isSSRConfig,
-                isRspressSSGConfig: isRspressSSGConfig
-            };
-            api.expose(RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, generateMergedStatsAndManifestOptions);
-            api.onBeforeCreateCompiler(function(param) {
-                var bundlerConfigs = param.bundlerConfigs;
-                if (!bundlerConfigs) {
-                    throw new Error('Can not get bundlerConfigs!');
-                }
-                bundlerConfigs.forEach(function(bundlerConfig) {
-                    if (!isMFFormat(bundlerConfig) && !isRspress) {
-                        return;
-                    } else if (isStoryBook(originalRsbuildConfig)) {
-                        bundlerConfig.output.uniqueName = "".concat(moduleFederationOptions.name, "-storybook-host");
-                    } else {
-                        var _bundlerConfig_optimization, _bundlerConfig_optimization1, _bundlerConfig_output, _bundlerConfig_output1;
-                        utils.autoDeleteSplitChunkCacheGroups(moduleFederationOptions, bundlerConfig === null || bundlerConfig === void 0 ? void 0 : (_bundlerConfig_optimization = bundlerConfig.optimization) === null || _bundlerConfig_optimization === void 0 ? void 0 : _bundlerConfig_optimization.splitChunks);
-                        utils.addDataFetchExposes(moduleFederationOptions.exposes, isSSRConfig(bundlerConfig.name));
-                        (_bundlerConfig_optimization1 = bundlerConfig.optimization) === null || _bundlerConfig_optimization1 === void 0 ? true : delete _bundlerConfig_optimization1.runtimeChunk;
-                        var externals = bundlerConfig.externals;
-                        if (Array.isArray(externals)) {
-                            var sharedModules = new Set();
-                            bundlerConfig.externals = externals.filter(function(ext) {
-                                var sharedModule;
-                                if (utils.isRegExp(ext)) {
-                                    var match = shared.some(function(dep) {
-                                        if (ext.test(dep) || ext.test(pkgJson.name)) {
-                                            sharedModule = dep;
-                                            return true;
-                                        }
-                                        return false;
-                                    });
-                                    match && sharedModule && sharedModules.add(sharedModule);
-                                    return !match;
-                                }
-                                if (typeof ext === 'string') {
-                                    if (ext === pkgJson.name) {
-                                        return false;
-                                    }
-                                    var match1 = shared.some(function(dep) {
-                                        if (dep === ext) {
-                                            sharedModule = dep;
-                                        }
-                                        return dep === ext;
-                                    });
-                                    if (match1) {
-                                        sharedModule && sharedModules.add(sharedModule);
-                                        return false;
-                                    }
-                                    return true;
-                                }
-                                return true;
-                            });
-                            if (sharedModules.size > 0) {
-                                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                try {
-                                    for(var _iterator = sharedModules[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                        var sharedModule = _step.value;
-                                        logger.log("".concat(sharedModule, " is removed from externals because it is a shared module."));
-                                    }
-                                } catch (err) {
-                                    _didIteratorError = true;
-                                    _iteratorError = err;
-                                } finally{
-                                    try {
-                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                            _iterator.return();
-                                        }
-                                    } finally{
-                                        if (_didIteratorError) {
-                                            throw _iteratorError;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        if (!((_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.chunkLoadingGlobal) && !isSSRConfig(bundlerConfig.name) && !isRspressSSGConfig(bundlerConfig.name)) {
-                            bundlerConfig.output.chunkLoading = 'jsonp';
-                            bundlerConfig.output.chunkLoadingGlobal = "chunk_".concat(moduleFederationOptions.name);
-                        }
-                        if (!((_bundlerConfig_output1 = bundlerConfig.output) === null || _bundlerConfig_output1 === void 0 ? void 0 : _bundlerConfig_output1.uniqueName)) {
-                            bundlerConfig.output.uniqueName = moduleFederationOptions.name;
-                        }
-                        if (!bundlerConfig.plugins.find(function(p) {
-                            return p && p.name === rspack.PLUGIN_NAME;
-                        })) {
-                            var _bundlerConfig_output2;
-                            if (isSSRConfig(bundlerConfig.name)) {
-                                generateMergedStatsAndManifestOptions.options.nodePlugin = new rspack.ModuleFederationPlugin(utils.createSSRMFConfig(moduleFederationOptions));
-                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.nodePlugin);
-                                return;
-                            } else if (isRspressSSGConfig(bundlerConfig.name)) {
-                                var _bundlerConfig;
-                                var mfConfig = _object_spread_props(_object_spread({}, utils.createSSRMFConfig(moduleFederationOptions)), {
-                                    exposes: {},
-                                    manifest: false,
-                                    library: undefined
-                                });
-                                utils.patchSSRRspackConfig(bundlerConfig, mfConfig, constant.RSPRESS_SSR_DIR, callerName, false, false);
-                                (_bundlerConfig = bundlerConfig).output || (_bundlerConfig.output = {});
-                                bundlerConfig.output.publicPath = '/';
-                                bundlerConfig.output.asyncChunks = undefined;
-                                generateMergedStatsAndManifestOptions.options.rspressSSGPlugin = new rspack.ModuleFederationPlugin(mfConfig);
-                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.rspressSSGPlugin);
-                                return;
-                            }
-                            generateMergedStatsAndManifestOptions.options.browserPlugin = new rspack.ModuleFederationPlugin(moduleFederationOptions);
-                            generateMergedStatsAndManifestOptions.options.distOutputDir = ((_bundlerConfig_output2 = bundlerConfig.output) === null || _bundlerConfig_output2 === void 0 ? void 0 : _bundlerConfig_output2.path) || '';
-                            bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.browserPlugin);
-                        }
-                    }
-                });
-            });
-            var generateMergedStatsAndManifest = function() {
-                var _generateMergedStatsAndManifestOptions_options = generateMergedStatsAndManifestOptions.options, nodePlugin = _generateMergedStatsAndManifestOptions_options.nodePlugin, browserPlugin = _generateMergedStatsAndManifestOptions_options.browserPlugin, distOutputDir = _generateMergedStatsAndManifestOptions_options.distOutputDir;
-                if (!nodePlugin || !browserPlugin || !distOutputDir) {
-                    return;
-                }
-                utils.updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
-            };
-            api.onDevCompileDone(function() {
-                generateMergedStatsAndManifest();
-            });
-            api.onAfterBuild(function() {
-                generateMergedStatsAndManifest();
-            });
-        }
-    };
-};
-
-Object.defineProperty(exports, "PLUGIN_NAME", {
-  enumerable: true,
-  get: function () { return rspack.PLUGIN_NAME; }
-});
-Object.defineProperty(exports, "createModuleFederationConfig", {
-  enumerable: true,
-  get: function () { return sdk.createModuleFederationConfig; }
-});
-exports.SSR_DIR = utils.SSR_DIR;
-exports.RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = RSBUILD_PLUGIN_MODULE_FEDERATION_NAME;
-exports.isMFFormat = isMFFormat;
-exports.pluginModuleFederation = pluginModuleFederation;
-//# sourceMappingURL=index.cjs.js.map

package/dist/index.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}