@module-federation/rspack 0.0.0-fix-lazy-comile-20250925082726

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present hanric(2heal1)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# `@module-federation/rspack` Documentation

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present hanric(2heal1)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var plugin = require('./plugin.cjs.js');
+var core = require('@rspack/core');
+
+var ContainerPlugin = core.container.ContainerPlugin;
+var ContainerReferencePlugin = core.container.ContainerReferencePlugin;
+
+exports.ModuleFederationPlugin = plugin.ModuleFederationPlugin;
+exports.PLUGIN_NAME = plugin.PLUGIN_NAME;
+exports.ContainerPlugin = ContainerPlugin;
+exports.ContainerReferencePlugin = ContainerReferencePlugin;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.cjs.js.map

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

package/dist/index.d.ts

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

package/dist/index.esm.d.ts

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

package/dist/index.esm.mjs

@@ -0,0 +1,8 @@
+export { ModuleFederationPlugin, PLUGIN_NAME } from './plugin.esm.mjs';
+import { container } from '@rspack/core';
+
+var ContainerPlugin = container.ContainerPlugin;
+var ContainerReferencePlugin = container.ContainerReferencePlugin;
+
+export { ContainerPlugin, ContainerReferencePlugin };
+//# sourceMappingURL=index.esm.mjs.map

package/dist/index.esm.mjs.map

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

package/dist/plugin.cjs.js

@@ -0,0 +1,301 @@
+'use strict';
+
+var sdk = require('@module-federation/sdk');
+var manifest = require('@module-federation/manifest');
+var managers = require('@module-federation/managers');
+var dtsPlugin = require('@module-federation/dts-plugin');
+var ReactBridgePlugin = require('@module-federation/bridge-react-webpack-plugin');
+var path = require('node:path');
+var fs = require('node:fs');
+var remoteEntryPlugin = require('./remote-entry-plugin.cjs.js');
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var RuntimeToolsPath = require.resolve('@module-federation/runtime-tools');
+var PLUGIN_NAME = 'RspackModuleFederationPlugin';
+var ModuleFederationPlugin = /*#__PURE__*/ function() {
+    function ModuleFederationPlugin(options) {
+        _class_call_check(this, ModuleFederationPlugin);
+        this.name = PLUGIN_NAME;
+        this._options = options;
+    }
+    _create_class(ModuleFederationPlugin, [
+        {
+            key: "_patchBundlerConfig",
+            value: function _patchBundlerConfig(compiler) {
+                var _experiments_optimization;
+                var _this__options = this._options, name = _this__options.name, experiments = _this__options.experiments;
+                var definePluginOptions = {};
+                if (name) {
+                    definePluginOptions['FEDERATION_BUILD_IDENTIFIER'] = JSON.stringify(sdk.composeKeyWithSeparator(name, managers.utils.getBuildVersion()));
+                }
+                var _experiments_optimization_disableSnapshot;
+                // Add FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN
+                var disableSnapshot = (_experiments_optimization_disableSnapshot = experiments === null || experiments === void 0 ? void 0 : (_experiments_optimization = experiments.optimization) === null || _experiments_optimization === void 0 ? void 0 : _experiments_optimization.disableSnapshot) !== null && _experiments_optimization_disableSnapshot !== void 0 ? _experiments_optimization_disableSnapshot : false;
+                definePluginOptions['FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN'] = disableSnapshot;
+                // Determine ENV_TARGET: only if manually specified in experiments.optimization.target
+                if ((experiments === null || experiments === void 0 ? void 0 : experiments.optimization) && _type_of(experiments.optimization) === 'object' && experiments.optimization !== null && 'target' in experiments.optimization) {
+                    var manualTarget = experiments.optimization.target;
+                    // Ensure the target is one of the expected values before setting
+                    if (manualTarget === 'web' || manualTarget === 'node') {
+                        definePluginOptions['ENV_TARGET'] = JSON.stringify(manualTarget);
+                    }
+                }
+                // No inference for ENV_TARGET. If not manually set and valid, it's not defined.
+                new compiler.webpack.DefinePlugin(definePluginOptions).apply(compiler);
+            }
+        },
+        {
+            key: "_checkSingleton",
+            value: function _checkSingleton(compiler) {
+                var _this = this;
+                var count = 0;
+                compiler.options.plugins.forEach(function(p) {
+                    if ((typeof p === "undefined" ? "undefined" : _type_of(p)) !== 'object' || !p) {
+                        return;
+                    }
+                    if (p['name'] === _this.name) {
+                        count++;
+                        if (count > 1) {
+                            throw new Error("Detect duplicate register ".concat(_this.name, ",please ensure ").concat(_this.name, " is singleton!"));
+                        }
+                    }
+                });
+            }
+        },
+        {
+            key: "apply",
+            value: function apply(compiler) {
+                var _options_experiments, _options_experiments1;
+                var _this = this, options = _this._options;
+                if (!options.name) {
+                    throw new Error('[ ModuleFederationPlugin ]: name is required');
+                }
+                this._checkSingleton(compiler);
+                this._patchBundlerConfig(compiler);
+                var containerManager = new managers.ContainerManager();
+                containerManager.init(options);
+                if (containerManager.enable) {
+                    this._patchChunkSplit(compiler, options.name);
+                }
+                // must before ModuleFederationPlugin
+                new remoteEntryPlugin.RemoteEntryPlugin(options).apply(compiler);
+                if ((_options_experiments = options.experiments) === null || _options_experiments === void 0 ? void 0 : _options_experiments.provideExternalRuntime) {
+                    if (options.exposes) {
+                        throw new Error('You can only set provideExternalRuntime: true in pure consumer which not expose modules.');
+                    }
+                    var runtimePlugins = options.runtimePlugins || [];
+                    options.runtimePlugins = runtimePlugins.concat(require.resolve('@module-federation/inject-external-runtime-core-plugin'));
+                }
+                if (((_options_experiments1 = options.experiments) === null || _options_experiments1 === void 0 ? void 0 : _options_experiments1.externalRuntime) === true) {
+                    var Externals = compiler.webpack.ExternalsPlugin;
+                    new Externals(compiler.options.externalsType || 'global', {
+                        '@module-federation/runtime-core': '_FEDERATION_RUNTIME_CORE'
+                    }).apply(compiler);
+                }
+                options.implementation = options.implementation || RuntimeToolsPath;
+                var disableManifest = options.manifest === false;
+                var disableDts = options.dts === false;
+                if (!disableDts) {
+                    var dtsPlugin$1 = new dtsPlugin.DtsPlugin(options);
+                    // @ts-ignore
+                    dtsPlugin$1.apply(compiler);
+                    dtsPlugin$1.addRuntimePlugins();
+                }
+                if (!disableManifest && options.exposes) {
+                    try {
+                        options.exposes = containerManager.containerPluginExposesOptions;
+                    } catch (err) {
+                        if (_instanceof(err, Error)) {
+                            err.message = "[ ModuleFederationPlugin ]: Manifest will not generate, because: ".concat(err.message);
+                        }
+                        console.warn(err);
+                        disableManifest = true;
+                    }
+                }
+                new compiler.webpack.container.ModuleFederationPlugin(options).apply(compiler);
+                var runtimeESMPath = require.resolve('@module-federation/runtime/dist/index.esm.js', {
+                    paths: [
+                        options.implementation
+                    ]
+                });
+                compiler.hooks.afterPlugins.tap('PatchAliasWebpackPlugin', function() {
+                    compiler.options.resolve.alias = _object_spread_props(_object_spread({}, compiler.options.resolve.alias), {
+                        '@module-federation/runtime$': runtimeESMPath
+                    });
+                });
+                if (!disableManifest) {
+                    this._statsPlugin = new manifest.StatsPlugin(options, {
+                        pluginVersion: "0.0.0-fix-lazy-comile-20250925082726",
+                        bundler: 'rspack'
+                    });
+                    // @ts-ignore
+                    this._statsPlugin.apply(compiler);
+                }
+                // react bridge plugin
+                var nodeModulesPath = path.resolve(compiler.context, 'node_modules');
+                var reactPath = path.join(nodeModulesPath, '@module-federation/bridge-react');
+                // Check whether react exists
+                if (fs.existsSync(reactPath) && (!(options === null || options === void 0 ? void 0 : options.bridge) || !options.bridge.disableAlias)) {
+                    new ReactBridgePlugin({
+                        moduleFederationOptions: this._options
+                    }).apply(compiler);
+                }
+            }
+        },
+        {
+            key: "_patchChunkSplit",
+            value: function _patchChunkSplit(compiler, name) {
+                var splitChunks = compiler.options.optimization.splitChunks;
+                var patchChunkSplit = function(cacheGroup) {
+                    switch(typeof cacheGroup === "undefined" ? "undefined" : _type_of(cacheGroup)){
+                        case 'boolean':
+                        case 'string':
+                        case 'function':
+                            break;
+                        //  cacheGroup.chunks will inherit splitChunks.chunks, so you only need to modify the chunks that are set separately
+                        case 'object':
+                            {
+                                if (_instanceof(cacheGroup, RegExp)) {
+                                    break;
+                                }
+                                if (!cacheGroup.chunks) {
+                                    break;
+                                }
+                                if (typeof cacheGroup.chunks === 'function') {
+                                    var prevChunks = cacheGroup.chunks;
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return prevChunks(chunk);
+                                    };
+                                    break;
+                                }
+                                if (cacheGroup.chunks === 'all') {
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return true;
+                                    };
+                                    break;
+                                }
+                                if (cacheGroup.chunks === 'initial') {
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return chunk.isOnlyInitial();
+                                    };
+                                    break;
+                                }
+                                break;
+                            }
+                    }
+                };
+                if (!splitChunks) {
+                    return;
+                }
+                // 修改 splitChunk.chunks
+                patchChunkSplit(splitChunks);
+                var cacheGroups = splitChunks.cacheGroups;
+                if (!cacheGroups) {
+                    return;
+                }
+                // 修改 splitChunk.cacheGroups[key].chunks
+                Object.keys(cacheGroups).forEach(function(cacheGroupKey) {
+                    patchChunkSplit(cacheGroups[cacheGroupKey]);
+                });
+            }
+        },
+        {
+            key: "statsResourceInfo",
+            get: function get() {
+                var _this__statsPlugin;
+                return (_this__statsPlugin = this._statsPlugin) === null || _this__statsPlugin === void 0 ? void 0 : _this__statsPlugin.resourceInfo;
+            }
+        }
+    ]);
+    return ModuleFederationPlugin;
+}();
+var GetPublicPathPlugin = remoteEntryPlugin.RemoteEntryPlugin;
+
+exports.GetPublicPathPlugin = GetPublicPathPlugin;
+exports.ModuleFederationPlugin = ModuleFederationPlugin;
+exports.PLUGIN_NAME = PLUGIN_NAME;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

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

package/dist/plugin.d.ts

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

package/dist/plugin.esm.d.ts

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

package/dist/plugin.esm.mjs

@@ -0,0 +1,297 @@
+import { composeKeyWithSeparator } from '@module-federation/sdk';
+import { StatsPlugin } from '@module-federation/manifest';
+import { utils, ContainerManager } from '@module-federation/managers';
+import { DtsPlugin } from '@module-federation/dts-plugin';
+import ReactBridgePlugin from '@module-federation/bridge-react-webpack-plugin';
+import path from 'node:path';
+import fs from 'node:fs';
+import { RemoteEntryPlugin } from './remote-entry-plugin.esm.mjs';
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var RuntimeToolsPath = require.resolve('@module-federation/runtime-tools');
+var PLUGIN_NAME = 'RspackModuleFederationPlugin';
+var ModuleFederationPlugin = /*#__PURE__*/ function() {
+    function ModuleFederationPlugin(options) {
+        _class_call_check(this, ModuleFederationPlugin);
+        this.name = PLUGIN_NAME;
+        this._options = options;
+    }
+    _create_class(ModuleFederationPlugin, [
+        {
+            key: "_patchBundlerConfig",
+            value: function _patchBundlerConfig(compiler) {
+                var _experiments_optimization;
+                var _this__options = this._options, name = _this__options.name, experiments = _this__options.experiments;
+                var definePluginOptions = {};
+                if (name) {
+                    definePluginOptions['FEDERATION_BUILD_IDENTIFIER'] = JSON.stringify(composeKeyWithSeparator(name, utils.getBuildVersion()));
+                }
+                var _experiments_optimization_disableSnapshot;
+                // Add FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN
+                var disableSnapshot = (_experiments_optimization_disableSnapshot = experiments === null || experiments === void 0 ? void 0 : (_experiments_optimization = experiments.optimization) === null || _experiments_optimization === void 0 ? void 0 : _experiments_optimization.disableSnapshot) !== null && _experiments_optimization_disableSnapshot !== void 0 ? _experiments_optimization_disableSnapshot : false;
+                definePluginOptions['FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN'] = disableSnapshot;
+                // Determine ENV_TARGET: only if manually specified in experiments.optimization.target
+                if ((experiments === null || experiments === void 0 ? void 0 : experiments.optimization) && _type_of(experiments.optimization) === 'object' && experiments.optimization !== null && 'target' in experiments.optimization) {
+                    var manualTarget = experiments.optimization.target;
+                    // Ensure the target is one of the expected values before setting
+                    if (manualTarget === 'web' || manualTarget === 'node') {
+                        definePluginOptions['ENV_TARGET'] = JSON.stringify(manualTarget);
+                    }
+                }
+                // No inference for ENV_TARGET. If not manually set and valid, it's not defined.
+                new compiler.webpack.DefinePlugin(definePluginOptions).apply(compiler);
+            }
+        },
+        {
+            key: "_checkSingleton",
+            value: function _checkSingleton(compiler) {
+                var _this = this;
+                var count = 0;
+                compiler.options.plugins.forEach(function(p) {
+                    if ((typeof p === "undefined" ? "undefined" : _type_of(p)) !== 'object' || !p) {
+                        return;
+                    }
+                    if (p['name'] === _this.name) {
+                        count++;
+                        if (count > 1) {
+                            throw new Error("Detect duplicate register ".concat(_this.name, ",please ensure ").concat(_this.name, " is singleton!"));
+                        }
+                    }
+                });
+            }
+        },
+        {
+            key: "apply",
+            value: function apply(compiler) {
+                var _options_experiments, _options_experiments1;
+                var _this = this, options = _this._options;
+                if (!options.name) {
+                    throw new Error('[ ModuleFederationPlugin ]: name is required');
+                }
+                this._checkSingleton(compiler);
+                this._patchBundlerConfig(compiler);
+                var containerManager = new ContainerManager();
+                containerManager.init(options);
+                if (containerManager.enable) {
+                    this._patchChunkSplit(compiler, options.name);
+                }
+                // must before ModuleFederationPlugin
+                new RemoteEntryPlugin(options).apply(compiler);
+                if ((_options_experiments = options.experiments) === null || _options_experiments === void 0 ? void 0 : _options_experiments.provideExternalRuntime) {
+                    if (options.exposes) {
+                        throw new Error('You can only set provideExternalRuntime: true in pure consumer which not expose modules.');
+                    }
+                    var runtimePlugins = options.runtimePlugins || [];
+                    options.runtimePlugins = runtimePlugins.concat(require.resolve('@module-federation/inject-external-runtime-core-plugin'));
+                }
+                if (((_options_experiments1 = options.experiments) === null || _options_experiments1 === void 0 ? void 0 : _options_experiments1.externalRuntime) === true) {
+                    var Externals = compiler.webpack.ExternalsPlugin;
+                    new Externals(compiler.options.externalsType || 'global', {
+                        '@module-federation/runtime-core': '_FEDERATION_RUNTIME_CORE'
+                    }).apply(compiler);
+                }
+                options.implementation = options.implementation || RuntimeToolsPath;
+                var disableManifest = options.manifest === false;
+                var disableDts = options.dts === false;
+                if (!disableDts) {
+                    var dtsPlugin = new DtsPlugin(options);
+                    // @ts-ignore
+                    dtsPlugin.apply(compiler);
+                    dtsPlugin.addRuntimePlugins();
+                }
+                if (!disableManifest && options.exposes) {
+                    try {
+                        options.exposes = containerManager.containerPluginExposesOptions;
+                    } catch (err) {
+                        if (_instanceof(err, Error)) {
+                            err.message = "[ ModuleFederationPlugin ]: Manifest will not generate, because: ".concat(err.message);
+                        }
+                        console.warn(err);
+                        disableManifest = true;
+                    }
+                }
+                new compiler.webpack.container.ModuleFederationPlugin(options).apply(compiler);
+                var runtimeESMPath = require.resolve('@module-federation/runtime/dist/index.esm.js', {
+                    paths: [
+                        options.implementation
+                    ]
+                });
+                compiler.hooks.afterPlugins.tap('PatchAliasWebpackPlugin', function() {
+                    compiler.options.resolve.alias = _object_spread_props(_object_spread({}, compiler.options.resolve.alias), {
+                        '@module-federation/runtime$': runtimeESMPath
+                    });
+                });
+                if (!disableManifest) {
+                    this._statsPlugin = new StatsPlugin(options, {
+                        pluginVersion: "0.0.0-fix-lazy-comile-20250925082726",
+                        bundler: 'rspack'
+                    });
+                    // @ts-ignore
+                    this._statsPlugin.apply(compiler);
+                }
+                // react bridge plugin
+                var nodeModulesPath = path.resolve(compiler.context, 'node_modules');
+                var reactPath = path.join(nodeModulesPath, '@module-federation/bridge-react');
+                // Check whether react exists
+                if (fs.existsSync(reactPath) && (!(options === null || options === void 0 ? void 0 : options.bridge) || !options.bridge.disableAlias)) {
+                    new ReactBridgePlugin({
+                        moduleFederationOptions: this._options
+                    }).apply(compiler);
+                }
+            }
+        },
+        {
+            key: "_patchChunkSplit",
+            value: function _patchChunkSplit(compiler, name) {
+                var splitChunks = compiler.options.optimization.splitChunks;
+                var patchChunkSplit = function(cacheGroup) {
+                    switch(typeof cacheGroup === "undefined" ? "undefined" : _type_of(cacheGroup)){
+                        case 'boolean':
+                        case 'string':
+                        case 'function':
+                            break;
+                        //  cacheGroup.chunks will inherit splitChunks.chunks, so you only need to modify the chunks that are set separately
+                        case 'object':
+                            {
+                                if (_instanceof(cacheGroup, RegExp)) {
+                                    break;
+                                }
+                                if (!cacheGroup.chunks) {
+                                    break;
+                                }
+                                if (typeof cacheGroup.chunks === 'function') {
+                                    var prevChunks = cacheGroup.chunks;
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return prevChunks(chunk);
+                                    };
+                                    break;
+                                }
+                                if (cacheGroup.chunks === 'all') {
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return true;
+                                    };
+                                    break;
+                                }
+                                if (cacheGroup.chunks === 'initial') {
+                                    cacheGroup.chunks = function(chunk) {
+                                        if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                            return false;
+                                        }
+                                        return chunk.isOnlyInitial();
+                                    };
+                                    break;
+                                }
+                                break;
+                            }
+                    }
+                };
+                if (!splitChunks) {
+                    return;
+                }
+                // 修改 splitChunk.chunks
+                patchChunkSplit(splitChunks);
+                var cacheGroups = splitChunks.cacheGroups;
+                if (!cacheGroups) {
+                    return;
+                }
+                // 修改 splitChunk.cacheGroups[key].chunks
+                Object.keys(cacheGroups).forEach(function(cacheGroupKey) {
+                    patchChunkSplit(cacheGroups[cacheGroupKey]);
+                });
+            }
+        },
+        {
+            key: "statsResourceInfo",
+            get: function get() {
+                var _this__statsPlugin;
+                return (_this__statsPlugin = this._statsPlugin) === null || _this__statsPlugin === void 0 ? void 0 : _this__statsPlugin.resourceInfo;
+            }
+        }
+    ]);
+    return ModuleFederationPlugin;
+}();
+var GetPublicPathPlugin = RemoteEntryPlugin;
+
+export { GetPublicPathPlugin, ModuleFederationPlugin, PLUGIN_NAME };
+//# sourceMappingURL=plugin.esm.mjs.map

package/dist/plugin.esm.mjs.map

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

package/dist/remote-entry-plugin.cjs.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var pBtoa = require('btoa');
+var managers = require('@module-federation/managers');
+var sdk = require('@module-federation/sdk');
+
+var logger = sdk.createLogger('[ Module Federation Rspack Plugin ]');
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+// @ts-ignore
+var charMap = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '/': '\\u002F',
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '\0': '\\0',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+function escapeUnsafeChars(str) {
+    return str.replace(/[<>\b\f\n\r\t\0\u2028\u2029\\]/g, function(x) {
+        return charMap[x];
+    });
+}
+var RemoteEntryPlugin = /*#__PURE__*/ function() {
+    function RemoteEntryPlugin(options) {
+        _class_call_check(this, RemoteEntryPlugin);
+        this.name = 'VmokRemoteEntryPlugin';
+        this._options = options;
+    }
+    _create_class(RemoteEntryPlugin, [
+        {
+            key: "apply",
+            value: function apply(compiler) {
+                var _this__options = this._options, name = _this__options.name, getPublicPath = _this__options.getPublicPath;
+                if (!getPublicPath || !name) {
+                    return;
+                }
+                var containerManager = new managers.ContainerManager();
+                containerManager.init(this._options);
+                if (!containerManager.enable) {
+                    logger.warn("Detect you don't set exposes, 'getPublicPath' will not have effect.");
+                    return;
+                }
+                RemoteEntryPlugin.addPublicPathEntry(compiler, getPublicPath, name);
+            }
+        }
+    ], [
+        {
+            key: "addPublicPathEntry",
+            value: function addPublicPathEntry(compiler, getPublicPath, name) {
+                var code;
+                var sanitizedPublicPath = escapeUnsafeChars(getPublicPath);
+                if (!getPublicPath.startsWith('function')) {
+                    code = "".concat(compiler.webpack.RuntimeGlobals.publicPath, " = new Function(").concat(JSON.stringify(sanitizedPublicPath), ")()");
+                } else {
+                    code = "(".concat(sanitizedPublicPath, "())");
+                }
+                var base64Code = pBtoa(code);
+                var dataUrl = "data:text/javascript;base64,".concat(base64Code);
+                compiler.hooks.afterPlugins.tap('VmokRemoteEntryPlugin', function() {
+                    new compiler.webpack.EntryPlugin(compiler.context, dataUrl, {
+                        name: name
+                    }).apply(compiler);
+                });
+            }
+        }
+    ]);
+    return RemoteEntryPlugin;
+} 
+();
+
+exports.RemoteEntryPlugin = RemoteEntryPlugin;
+//# sourceMappingURL=remote-entry-plugin.cjs.js.map

package/dist/remote-entry-plugin.cjs.js.map

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

package/dist/remote-entry-plugin.d.ts

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

package/dist/remote-entry-plugin.esm.d.ts

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

package/dist/remote-entry-plugin.esm.mjs

@@ -0,0 +1,95 @@
+import pBtoa from 'btoa';
+import { ContainerManager } from '@module-federation/managers';
+import { createLogger } from '@module-federation/sdk';
+
+var logger = createLogger('[ Module Federation Rspack Plugin ]');
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+// @ts-ignore
+var charMap = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '/': '\\u002F',
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '\0': '\\0',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+function escapeUnsafeChars(str) {
+    return str.replace(/[<>\b\f\n\r\t\0\u2028\u2029\\]/g, function(x) {
+        return charMap[x];
+    });
+}
+var RemoteEntryPlugin = /*#__PURE__*/ function() {
+    function RemoteEntryPlugin(options) {
+        _class_call_check(this, RemoteEntryPlugin);
+        this.name = 'VmokRemoteEntryPlugin';
+        this._options = options;
+    }
+    _create_class(RemoteEntryPlugin, [
+        {
+            key: "apply",
+            value: function apply(compiler) {
+                var _this__options = this._options, name = _this__options.name, getPublicPath = _this__options.getPublicPath;
+                if (!getPublicPath || !name) {
+                    return;
+                }
+                var containerManager = new ContainerManager();
+                containerManager.init(this._options);
+                if (!containerManager.enable) {
+                    logger.warn("Detect you don't set exposes, 'getPublicPath' will not have effect.");
+                    return;
+                }
+                RemoteEntryPlugin.addPublicPathEntry(compiler, getPublicPath, name);
+            }
+        }
+    ], [
+        {
+            key: "addPublicPathEntry",
+            value: function addPublicPathEntry(compiler, getPublicPath, name) {
+                var code;
+                var sanitizedPublicPath = escapeUnsafeChars(getPublicPath);
+                if (!getPublicPath.startsWith('function')) {
+                    code = "".concat(compiler.webpack.RuntimeGlobals.publicPath, " = new Function(").concat(JSON.stringify(sanitizedPublicPath), ")()");
+                } else {
+                    code = "(".concat(sanitizedPublicPath, "())");
+                }
+                var base64Code = pBtoa(code);
+                var dataUrl = "data:text/javascript;base64,".concat(base64Code);
+                compiler.hooks.afterPlugins.tap('VmokRemoteEntryPlugin', function() {
+                    new compiler.webpack.EntryPlugin(compiler.context, dataUrl, {
+                        name: name
+                    }).apply(compiler);
+                });
+            }
+        }
+    ]);
+    return RemoteEntryPlugin;
+} 
+();
+
+export { RemoteEntryPlugin };
+//# sourceMappingURL=remote-entry-plugin.esm.mjs.map

package/dist/remote-entry-plugin.esm.mjs.map

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

package/dist/src/ModuleFederationPlugin.d.ts

@@ -0,0 +1,16 @@
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import { RemoteEntryPlugin } from './RemoteEntryPlugin';
+export declare const PLUGIN_NAME = "RspackModuleFederationPlugin";
+export declare class ModuleFederationPlugin implements RspackPluginInstance {
+    readonly name = "RspackModuleFederationPlugin";
+    private _options;
+    private _statsPlugin?;
+    constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
+    private _patchBundlerConfig;
+    private _checkSingleton;
+    apply(compiler: Compiler): void;
+    private _patchChunkSplit;
+    get statsResourceInfo(): Partial<import("@module-federation/manifest").ResourceInfo> | undefined;
+}
+export declare const GetPublicPathPlugin: typeof RemoteEntryPlugin;

package/dist/src/RemoteEntryPlugin.d.ts

@@ -0,0 +1,9 @@
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+export declare class RemoteEntryPlugin implements RspackPluginInstance {
+    readonly name = "VmokRemoteEntryPlugin";
+    _options: moduleFederationPlugin.ModuleFederationPluginOptions;
+    constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
+    static addPublicPathEntry(compiler: Compiler, getPublicPath: string, name: string): void;
+    apply(compiler: Compiler): void;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { ModuleFederationPlugin, PLUGIN_NAME } from './ModuleFederationPlugin';
+export declare const ContainerPlugin: typeof import("@rspack/core/dist/container/ContainerPlugin").ContainerPlugin;
+export declare const ContainerReferencePlugin: typeof import("@rspack/core/dist/container/ContainerReferencePlugin").ContainerReferencePlugin;

package/dist/src/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("@module-federation/sdk").Logger;
+export default logger;

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@module-federation/rspack",
+  "version": "0.0.0-fix-lazy-comile-20250925082726",
+  "license": "MIT",
+  "keywords": [
+    "Module Federation",
+    "Rspack"
+  ],
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/rspack"
+  },
+  "author": "hanric <hanric.zhang@gmail.com>",
+  "sideEffects": false,
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.mjs",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "btoa": "1.2.1",
+    "@module-federation/bridge-react-webpack-plugin": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/managers": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/dts-plugin": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/manifest": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/runtime-tools": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/inject-external-runtime-core-plugin": "0.0.0-fix-lazy-comile-20250925082726",
+    "@module-federation/sdk": "0.0.0-fix-lazy-comile-20250925082726"
+  },
+  "devDependencies": {
+    "@rspack/core": "^1.0.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.mjs",
+      "require": "./dist/index.cjs.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.esm.mjs",
+      "require": "./dist/plugin.cjs.js"
+    },
+    "./remote-entry-plugin": {
+      "types": "./dist/remote-entry-plugin.d.ts",
+      "import": "./dist/remote-entry-plugin.esm.mjs",
+      "require": "./dist/remote-entry-plugin.cjs.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "plugin": [
+        "./dist/plugin.d.ts"
+      ],
+      "remote-entry-plugin": [
+        "./dist/remote-entry-plugin.d.ts"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "typescript": "^4.9.0 || ^5.0.0",
+    "vue-tsc": ">=1.0.24",
+    "@rspack/core": ">=0.7"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    },
+    "vue-tsc": {
+      "optional": true
+    }
+  }
+}