@module-federation/rsbuild-plugin 0.19.1 → 0.20.0

package/dist/index.d.ts

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

package/dist/index.esm.d.ts

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

package/dist/index.esm.mjs

@@ -1,349 +0,0 @@
-import { parseOptions } from '@module-federation/enhanced';
-import { PLUGIN_NAME, ModuleFederationPlugin } from '@module-federation/enhanced/rspack';
-export { PLUGIN_NAME } from '@module-federation/enhanced/rspack';
-import { createLogger, isRequiredVersion } from '@module-federation/sdk';
-export { createModuleFederationConfig } from '@module-federation/sdk';
-import { SSR_ENV_NAME, setSSREnv, createSSRREnvConfig, autoDeleteSplitChunkCacheGroups, addDataFetchExposes, isRegExp, createSSRMFConfig, patchSSRRspackConfig, updateStatsAndManifest, SSR_DIR } from './utils.esm.mjs';
-import { CALL_NAME_MAP, RSPRESS_BUNDLER_CONFIG_NAME, RSPRESS_SSR_DIR } from './constant.esm.mjs';
-import 'util';
-import 'fs-extra';
-import 'path';
-import 'node:module';
-
-var name = "@module-federation/rsbuild-plugin";
-var pkgJson = {
-    name: name};
-
-var logger = 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 === 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 === SSR_ENV_NAME);
-};
-var isRspressSSGConfig = function(bundlerConfigName) {
-    return bundlerConfigName === 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 ? 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 === CALL_NAME_MAP.RSLIB;
-            var isRspress = callerName === 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' ."));
-                }
-                setSSREnv();
-            }
-            var sharedOptions = parseOptions(moduleFederationOptions.shared || [], function(item, key) {
-                if (typeof item !== 'string') throw new Error('Unexpected array in shared');
-                var config = item === key || !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[SSR_ENV_NAME]) {
-                        throw new Error("'".concat(SSR_ENV_NAME, "' environment is already defined. Please use another name."));
-                    }
-                    config.environments[SSR_ENV_NAME] = 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;
-                        autoDeleteSplitChunkCacheGroups(moduleFederationOptions, bundlerConfig === null || bundlerConfig === void 0 ? void 0 : (_bundlerConfig_optimization = bundlerConfig.optimization) === null || _bundlerConfig_optimization === void 0 ? void 0 : _bundlerConfig_optimization.splitChunks);
-                        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 (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 === PLUGIN_NAME;
-                        })) {
-                            var _bundlerConfig_output2;
-                            if (isSSRConfig(bundlerConfig.name)) {
-                                generateMergedStatsAndManifestOptions.options.nodePlugin = new ModuleFederationPlugin(createSSRMFConfig(moduleFederationOptions));
-                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.nodePlugin);
-                                return;
-                            } else if (isRspressSSGConfig(bundlerConfig.name)) {
-                                var _bundlerConfig;
-                                var mfConfig = _object_spread_props(_object_spread({}, createSSRMFConfig(moduleFederationOptions)), {
-                                    exposes: {},
-                                    manifest: false,
-                                    library: undefined
-                                });
-                                patchSSRRspackConfig(bundlerConfig, mfConfig, RSPRESS_SSR_DIR, callerName, false, false);
-                                (_bundlerConfig = bundlerConfig).output || (_bundlerConfig.output = {});
-                                bundlerConfig.output.publicPath = '/';
-                                bundlerConfig.output.asyncChunks = undefined;
-                                generateMergedStatsAndManifestOptions.options.rspressSSGPlugin = new ModuleFederationPlugin(mfConfig);
-                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.rspressSSGPlugin);
-                                return;
-                            }
-                            generateMergedStatsAndManifestOptions.options.browserPlugin = new 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;
-                }
-                updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
-            };
-            api.onDevCompileDone(function() {
-                generateMergedStatsAndManifest();
-            });
-            api.onAfterBuild(function() {
-                generateMergedStatsAndManifest();
-            });
-        }
-    };
-};
-
-export { RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, SSR_DIR, isMFFormat, pluginModuleFederation };
-//# sourceMappingURL=index.esm.mjs.map

package/dist/index.esm.mjs.map

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

package/dist/src/constant.d.ts

@@ -1,9 +0,0 @@
-export declare const DEFAULT_ASSET_PREFIX = "/";
-export declare const DATA_FETCH_IDENTIFIER = "data";
-export declare const DATA_FETCH_CLIENT_SUFFIX = ".client";
-export declare const CALL_NAME_MAP: {
-    RSPRESS: string;
-    RSLIB: string;
-};
-export declare const RSPRESS_BUNDLER_CONFIG_NAME = "node";
-export declare const RSPRESS_SSR_DIR = "ssr";