@module-federation/rspack 0.0.0-perf-devtools-20260107043700 → 0.0.0-perf-website-code-usage-20260914033703

package/dist/{plugin.esm.mjs → ModuleFederationPlugin.mjs}

@@ -1,34 +1,86 @@
-import { composeKeyWithSeparator, bindLoggerToCompiler } 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 { R as RemoteEntryPlugin, l as logger } from './RemoteEntryPlugin.esm.mjs';
+import { bindLoggerToCompiler, composeKeyWithSeparator } from "@module-federation/sdk";
+import { StatsPlugin } from "@module-federation/manifest";
+import { ContainerManager, utils } from "@module-federation/managers";
+import { DtsPlugin } from "@module-federation/dts-plugin";
+import bridge_react_webpack_plugin from "@module-federation/bridge-react-webpack-plugin";
+import node_path from "node:path";
+import node_fs from "node:fs";
+import { RemoteEntryPlugin } from "./RemoteEntryPlugin.mjs";
+import logger from "./logger.mjs";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-const RuntimeToolsPath = require.resolve('@module-federation/runtime-tools');
 const PLUGIN_NAME = 'RspackModuleFederationPlugin';
-class ModuleFederationPlugin {
-    constructor(options) {
-        this.name = PLUGIN_NAME;
-        this._options = options;
+function hasExposes(exposes) {
+    return Boolean(exposes && (Array.isArray(exposes) ? exposes.length > 0 : Object.keys(exposes).length > 0));
+}
+function resolveRuntimeEntry(spec, implementation, resolve = require.resolve) {
+    const candidates = [
+        spec.bundler,
+        spec.esm,
+        spec.cjs
+    ];
+    const modulePaths = implementation ? [
+        implementation
+    ] : undefined;
+    let lastError;
+    for (const candidate of candidates){
+        try {
+            return modulePaths ? resolve(candidate, {
+                paths: modulePaths
+            }) : resolve(candidate);
+        } catch (error) {
+            lastError = error;
+        }
     }
+    throw lastError;
+}
+function resolveRspackRuntimeImplementation(implementation, resolve = require.resolve) {
+    return resolveRuntimeEntry({
+        bundler: '@module-federation/runtime-tools/bundler',
+        esm: '@module-federation/runtime-tools/dist/index.js',
+        cjs: '@module-federation/runtime-tools/dist/index.cjs'
+    }, implementation, resolve);
+}
+function resolveRspackRuntimeAlias(implementation, resolve = require.resolve) {
+    return resolveRuntimeEntry({
+        bundler: '@module-federation/runtime/bundler',
+        esm: '@module-federation/runtime/dist/index.js',
+        cjs: '@module-federation/runtime/dist/index.cjs'
+    }, implementation, resolve);
+}
+class ModuleFederationPlugin {
     _patchBundlerConfig(compiler) {
-        const { name, experiments } = this._options;
+        const { name, experiments, exposes } = this._options;
         const definePluginOptions = {};
         if (name) {
             definePluginOptions['FEDERATION_BUILD_IDENTIFIER'] = JSON.stringify(composeKeyWithSeparator(name, utils.getBuildVersion()));
         }
         // Add FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN
         const disableSnapshot = experiments?.optimization?.disableSnapshot ?? false;
-        definePluginOptions['FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN'] =
-            disableSnapshot;
+        definePluginOptions['FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN'] = disableSnapshot;
+        definePluginOptions['FEDERATION_OPTIMIZE_NO_REMOTE'] = experiments?.optimization?.disableRemote ?? false;
+        definePluginOptions['FEDERATION_OPTIMIZE_NO_SHARED'] = experiments?.optimization?.disableShared ?? false;
+        definePluginOptions['FEDERATION_HAS_EXPOSES'] = hasExposes(exposes);
         // Determine ENV_TARGET: only if manually specified in experiments.optimization.target
-        if (experiments?.optimization &&
-            typeof experiments.optimization === 'object' &&
-            experiments.optimization !== null &&
-            'target' in experiments.optimization) {
+        if (experiments?.optimization && typeof experiments.optimization === 'object' && experiments.optimization !== null && 'target' in experiments.optimization) {
             const manualTarget = experiments.optimization.target;
             // Ensure the target is one of the expected values before setting
             if (manualTarget === 'web' || manualTarget === 'node') {
@@ -40,7 +92,7 @@ class ModuleFederationPlugin {
     }
     _checkSingleton(compiler) {
         let count = 0;
-        compiler.options.plugins.forEach((p) => {
+        compiler.options.plugins.forEach((p)=>{
             if (typeof p !== 'object' || !p) {
                 return;
             }
@@ -68,7 +120,7 @@ class ModuleFederationPlugin {
         // must before ModuleFederationPlugin
         new RemoteEntryPlugin(options).apply(compiler);
         if (options.experiments?.provideExternalRuntime) {
-            if (options.exposes) {
+            if (containerManager.enable) {
                 throw new Error('You can only set provideExternalRuntime: true in pure consumer which not expose modules.');
             }
             const runtimePlugins = options.runtimePlugins || [];
@@ -77,10 +129,11 @@ class ModuleFederationPlugin {
         if (options.experiments?.externalRuntime === true) {
             const Externals = compiler.webpack.ExternalsPlugin;
             new Externals(compiler.options.externalsType || 'global', {
-                '@module-federation/runtime-core': '_FEDERATION_RUNTIME_CORE',
+                '@module-federation/runtime-core': '_FEDERATION_RUNTIME_CORE'
             }).apply(compiler);
         }
-        options.implementation = options.implementation || RuntimeToolsPath;
+        const implementationPath = options.implementation ? options.implementation : resolveRspackRuntimeImplementation();
+        options.implementation = implementationPath;
         let disableManifest = options.manifest === false;
         let disableDts = options.dts === false;
         if (!disableDts) {
@@ -92,8 +145,7 @@ class ModuleFederationPlugin {
         if (!disableManifest && options.exposes) {
             try {
                 options.exposes = containerManager.containerPluginExposesOptions;
-            }
-            catch (err) {
+            } catch (err) {
                 if (err instanceof Error) {
                     err.message = `[ ModuleFederationPlugin ]: Manifest will not generate, because: ${err.message}`;
                 }
@@ -102,68 +154,60 @@ class ModuleFederationPlugin {
             }
         }
         new compiler.webpack.container.ModuleFederationPlugin(options).apply(compiler);
-        const runtimeESMPath = require.resolve('@module-federation/runtime/dist/index.esm.js', { paths: [options.implementation] });
-        compiler.hooks.afterPlugins.tap('PatchAliasWebpackPlugin', () => {
+        let runtimePath;
+        try {
+            runtimePath = resolveRspackRuntimeAlias(implementationPath);
+        } catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`[ ModuleFederationPlugin ]: Unable to resolve runtime entry (paths: [${implementationPath}]): ${detail}`);
+        }
+        compiler.hooks.afterPlugins.tap('PatchAliasWebpackPlugin', ()=>{
             compiler.options.resolve.alias = {
                 ...compiler.options.resolve.alias,
-                '@module-federation/runtime$': runtimeESMPath,
+                '@module-federation/runtime$': runtimePath
             };
         });
         if (!disableManifest) {
             this._statsPlugin = new StatsPlugin(options, {
-                pluginVersion: "0.0.0-perf-devtools-20260107043700",
-                bundler: 'rspack',
+                pluginVersion: "0.0.0-perf-website-code-usage-20260914033703",
+                bundler: 'rspack'
             });
             // @ts-ignore
             this._statsPlugin.apply(compiler);
         }
-        const checkBridgeReactInstalled = () => {
+        const checkBridgeReactInstalled = ()=>{
             try {
-                const userPackageJsonPath = path.resolve(compiler.context, 'package.json');
-                if (fs.existsSync(userPackageJsonPath)) {
-                    const userPackageJson = JSON.parse(fs.readFileSync(userPackageJsonPath, 'utf-8'));
+                const userPackageJsonPath = node_path.resolve(compiler.context, 'package.json');
+                if (node_fs.existsSync(userPackageJsonPath)) {
+                    const userPackageJson = JSON.parse(node_fs.readFileSync(userPackageJsonPath, 'utf-8'));
                     const userDependencies = {
                         ...userPackageJson.dependencies,
-                        ...userPackageJson.devDependencies,
+                        ...userPackageJson.devDependencies
                     };
                     return !!userDependencies['@module-federation/bridge-react'];
                 }
                 return false;
-            }
-            catch (error) {
+            } catch (error) {
                 return false;
             }
         };
         const hasBridgeReact = checkBridgeReactInstalled();
         // react bridge plugin
-        const shouldEnableBridgePlugin = () => {
+        const shouldEnableBridgePlugin = ()=>{
             // Priority 1: Explicit enableBridgeRouter configuration
             if (options?.bridge?.enableBridgeRouter === true) {
                 return true;
             }
             // Priority 2: Explicit disable via enableBridgeRouter:false or disableAlias:true
-            if (options?.bridge?.enableBridgeRouter === false ||
-                options?.bridge?.disableAlias === true) {
+            if (options?.bridge?.enableBridgeRouter === false || options?.bridge?.disableAlias === true) {
                 if (options?.bridge?.disableAlias === true) {
-                    logger.warn('⚠️  [ModuleFederationPlugin] The `disableAlias` option is deprecated and will be removed in a future version.\n' +
-                        '   Please use `enableBridgeRouter: false` instead:\n' +
-                        '   {\n' +
-                        '     bridge: {\n' +
-                        '       enableBridgeRouter: false  // Use this instead of disableAlias: true\n' +
-                        '     }\n' +
-                        '   }');
+                    logger.warn('⚠️  [ModuleFederationPlugin] The `disableAlias` option is deprecated and will be removed in a future version.\n' + '   Please use `enableBridgeRouter: false` instead:\n' + '   {\n' + '     bridge: {\n' + '       enableBridgeRouter: false  // Use this instead of disableAlias: true\n' + '     }\n' + '   }');
                 }
                 return false;
             }
             // Priority 3: Automatic detection based on bridge-react installation
             if (hasBridgeReact) {
-                logger.info('💡 [ModuleFederationPlugin] Detected @module-federation/bridge-react in your dependencies.\n' +
-                    '   For better control and to avoid future breaking changes, please explicitly set:\n' +
-                    '   {\n' +
-                    '     bridge: {\n' +
-                    '       enableBridgeRouter: true  // Explicitly enable bridge router\n' +
-                    '     }\n' +
-                    '   }');
+                logger.info('💡 [ModuleFederationPlugin] Detected @module-federation/bridge-react in your dependencies.\n' + '   For better control and to avoid future breaking changes, please explicitly set:\n' + '   {\n' + '     bridge: {\n' + '       enableBridgeRouter: true  // Explicitly enable bridge router\n' + '     }\n' + '   }');
                 return true;
             }
             return false;
@@ -171,79 +215,78 @@ class ModuleFederationPlugin {
         const enableBridgePlugin = shouldEnableBridgePlugin();
         // When bridge plugin is disabled (router disabled), alias to /base entry
         if (!enableBridgePlugin && hasBridgeReact) {
-            compiler.hooks.afterPlugins.tap('BridgeReactBaseAliasPlugin', () => {
+            compiler.hooks.afterPlugins.tap('BridgeReactBaseAliasPlugin', ()=>{
                 try {
-                    const bridgeReactBasePath = path.resolve(compiler.context, 'node_modules/@module-federation/bridge-react/dist/base.es.js');
-                    if (!fs.existsSync(bridgeReactBasePath)) {
+                    const bridgeReactBasePath = node_path.resolve(compiler.context, 'node_modules/@module-federation/bridge-react/dist/base.es.js');
+                    if (!node_fs.existsSync(bridgeReactBasePath)) {
                         logger.warn('⚠️  [ModuleFederationPlugin] bridge-react /base entry not found, falling back to default entry');
                         return;
                     }
                     compiler.options.resolve.alias = {
                         ...compiler.options.resolve.alias,
-                        '@module-federation/bridge-react$': bridgeReactBasePath,
+                        '@module-federation/bridge-react$': bridgeReactBasePath
                     };
                     logger.info('✅ [ModuleFederationPlugin] Router disabled - using /base entry (no react-router-dom)');
-                }
-                catch (error) {
+                } catch (error) {
                     logger.warn('⚠️  [ModuleFederationPlugin] Failed to set /base alias, using default entry');
                 }
             });
         }
         if (enableBridgePlugin) {
-            new ReactBridgePlugin({
-                moduleFederationOptions: this._options,
+            new bridge_react_webpack_plugin({
+                moduleFederationOptions: this._options
             }).apply(compiler);
         }
     }
     _patchChunkSplit(compiler, name) {
         const { splitChunks } = compiler.options.optimization;
-        const patchChunkSplit = (cacheGroup) => {
-            switch (typeof cacheGroup) {
+        const patchChunkSplit = (cacheGroup)=>{
+            switch(typeof 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 (cacheGroup instanceof RegExp) {
-                        break;
-                    }
-                    if (!cacheGroup.chunks) {
-                        break;
-                    }
-                    if (typeof cacheGroup.chunks === 'function') {
-                        const prevChunks = cacheGroup.chunks;
-                        cacheGroup.chunks = (chunk) => {
-                            if (chunk.name &&
-                                (chunk.name === name || chunk.name === name + '_partial')) {
-                                return false;
-                            }
-                            return prevChunks(chunk);
-                        };
-                        break;
-                    }
-                    if (cacheGroup.chunks === 'all') {
-                        cacheGroup.chunks = (chunk) => {
-                            if (chunk.name &&
-                                (chunk.name === name || chunk.name === name + '_partial')) {
-                                return false;
-                            }
-                            return true;
-                        };
-                        break;
-                    }
-                    if (cacheGroup.chunks === 'initial') {
-                        cacheGroup.chunks = (chunk) => {
-                            if (chunk.name &&
-                                (chunk.name === name || chunk.name === name + '_partial')) {
-                                return false;
-                            }
-                            return chunk.isOnlyInitial();
-                        };
+                case 'object':
+                    {
+                        if (cacheGroup instanceof RegExp) {
+                            break;
+                        }
+                        if (!cacheGroup.chunks) {
+                            break;
+                        }
+                        if (typeof cacheGroup.chunks === 'function') {
+                            const prevChunks = cacheGroup.chunks;
+                            cacheGroup.chunks = (chunk)=>{
+                                if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                    return false;
+                                }
+                                return prevChunks(chunk);
+                            };
+                            break;
+                        }
+                        if (cacheGroup.chunks === 'all') {
+                            cacheGroup.chunks = (chunk)=>{
+                                if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                    return false;
+                                }
+                                return true;
+                            };
+                            break;
+                        }
+                        if (cacheGroup.chunks === 'initial') {
+                            cacheGroup.chunks = (chunk)=>{
+                                if (chunk.name && (chunk.name === name || chunk.name === name + '_partial')) {
+                                    return false;
+                                }
+                                return chunk.isOnlyInitial();
+                            };
+                            break;
+                        }
                         break;
                     }
+                default:
                     break;
-                }
             }
         };
         if (!splitChunks) {
@@ -256,12 +299,17 @@ class ModuleFederationPlugin {
             return;
         }
         // 修改 splitChunk.cacheGroups[key].chunks
-        Object.keys(cacheGroups).forEach((cacheGroupKey) => {
+        Object.keys(cacheGroups).forEach((cacheGroupKey)=>{
             patchChunkSplit(cacheGroups[cacheGroupKey]);
         });
     }
+    constructor(options){
+        this.name = PLUGIN_NAME;
+        this._options = options;
+    }
 }
 const GetPublicPathPlugin = RemoteEntryPlugin;
 
-export { GetPublicPathPlugin, ModuleFederationPlugin, PLUGIN_NAME };
-//# sourceMappingURL=plugin.esm.mjs.map
+
+export { GetPublicPathPlugin, ModuleFederationPlugin, PLUGIN_NAME, resolveRspackRuntimeAlias, resolveRspackRuntimeImplementation };
+export { TreeShakingSharedPlugin } from "./TreeShakingSharedPlugin.mjs";

package/dist/RemoteEntryPlugin.js

@@ -0,0 +1,129 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  RemoteEntryPlugin: () => (/* binding */ RemoteEntryPlugin)
+});
+
+;// CONCATENATED MODULE: external "@module-federation/managers"
+const managers_namespaceObject = require("@module-federation/managers");
+;// CONCATENATED MODULE: external "./logger.js"
+const external_logger_js_namespaceObject = require("./logger.js");
+var external_logger_js_default = /*#__PURE__*/__webpack_require__.n(external_logger_js_namespaceObject);
+;// CONCATENATED MODULE: ./src/RemoteEntryPlugin.ts
+
+
+// @ts-ignore
+const 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, (x)=>charMap[x]);
+}
+class RemoteEntryPlugin {
+    static addPublicPathEntry(compiler, getPublicPath, name) {
+        let code;
+        const sanitizedPublicPath = escapeUnsafeChars(getPublicPath);
+        if (!getPublicPath.startsWith('function')) {
+            code = `${compiler.webpack.RuntimeGlobals.publicPath} = new Function(${JSON.stringify(sanitizedPublicPath)})()`;
+        } else {
+            code = `(${sanitizedPublicPath}())`;
+        }
+        const base64Code = Buffer.from(code, 'utf8').toString('base64');
+        const dataUrl = `data:text/javascript;base64,${base64Code}`;
+        compiler.hooks.afterPlugins.tap('VmokRemoteEntryPlugin', ()=>{
+            new compiler.webpack.EntryPlugin(compiler.context, dataUrl, {
+                name: name
+            }).apply(compiler);
+        });
+    }
+    apply(compiler) {
+        const { name, getPublicPath } = this._options;
+        if (!getPublicPath || !name) {
+            return;
+        }
+        const containerManager = new managers_namespaceObject.ContainerManager();
+        containerManager.init(this._options);
+        if (!containerManager.enable) {
+            external_logger_js_default().warn("Detect you don't set exposes, 'getPublicPath' will not have effect.");
+            return;
+        }
+        RemoteEntryPlugin.addPublicPathEntry(compiler, getPublicPath, name);
+    }
+    constructor(options){
+        this.name = 'VmokRemoteEntryPlugin';
+        this._options = options;
+    }
+}
+
+exports.RemoteEntryPlugin = __webpack_exports__.RemoteEntryPlugin;
+for(var __rspack_i in __webpack_exports__) {
+  if(["RemoteEntryPlugin"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/{RemoteEntryPlugin.esm.mjs → RemoteEntryPlugin.mjs}

@@ -1,12 +1,9 @@
-import pBtoa from 'btoa';
-import { ContainerManager } from '@module-federation/managers';
-import { createInfrastructureLogger, createLogger } from '@module-federation/sdk';
+import { ContainerManager } from "@module-federation/managers";
+import logger from "./logger.mjs";
+
+
+
 
-const isLoggerFactory = (candidate) => typeof candidate === 'function';
-const createBundlerLogger = isLoggerFactory(createInfrastructureLogger)
-    ? (prefix) => createInfrastructureLogger(prefix)
-    : createLogger;
-const logger = createBundlerLogger('[ Module Federation Rspack Plugin ]');
 
 // @ts-ignore
 const charMap = {
@@ -21,30 +18,25 @@ const charMap = {
     '\t': '\\t',
     '\0': '\\0',
     '\u2028': '\\u2028',
-    '\u2029': '\\u2029',
+    '\u2029': '\\u2029'
 };
 function escapeUnsafeChars(str) {
-    return str.replace(/[<>\b\f\n\r\t\0\u2028\u2029\\]/g, (x) => charMap[x]);
+    return str.replace(/[<>\b\f\n\r\t\0\u2028\u2029\\]/g, (x)=>charMap[x]);
 }
 class RemoteEntryPlugin {
-    constructor(options) {
-        this.name = 'VmokRemoteEntryPlugin';
-        this._options = options;
-    }
     static addPublicPathEntry(compiler, getPublicPath, name) {
         let code;
         const sanitizedPublicPath = escapeUnsafeChars(getPublicPath);
         if (!getPublicPath.startsWith('function')) {
             code = `${compiler.webpack.RuntimeGlobals.publicPath} = new Function(${JSON.stringify(sanitizedPublicPath)})()`;
-        }
-        else {
+        } else {
             code = `(${sanitizedPublicPath}())`;
         }
-        const base64Code = pBtoa(code);
+        const base64Code = Buffer.from(code, 'utf8').toString('base64');
         const dataUrl = `data:text/javascript;base64,${base64Code}`;
-        compiler.hooks.afterPlugins.tap('VmokRemoteEntryPlugin', () => {
+        compiler.hooks.afterPlugins.tap('VmokRemoteEntryPlugin', ()=>{
             new compiler.webpack.EntryPlugin(compiler.context, dataUrl, {
-                name: name,
+                name: name
             }).apply(compiler);
         });
     }
@@ -61,7 +53,10 @@ class RemoteEntryPlugin {
         }
         RemoteEntryPlugin.addPublicPathEntry(compiler, getPublicPath, name);
     }
+    constructor(options){
+        this.name = 'VmokRemoteEntryPlugin';
+        this._options = options;
+    }
 }
 
-export { RemoteEntryPlugin as R, logger as l };
-//# sourceMappingURL=RemoteEntryPlugin.esm.mjs.map
+export { RemoteEntryPlugin };

package/dist/TreeShakingSharedPlugin.d.ts

@@ -0,0 +1,13 @@
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+export declare const PLUGIN_NAME = "RspackTreeShakingSharedPlugin";
+export interface TreeShakingSharedPluginOptions {
+    mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    secondary?: boolean;
+}
+export declare class TreeShakingSharedPlugin implements RspackPluginInstance {
+    readonly name = "RspackTreeShakingSharedPlugin";
+    private _options;
+    constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/TreeShakingSharedPlugin.js

@@ -0,0 +1,67 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const PLUGIN_NAME = 'RspackTreeShakingSharedPlugin';
+class TreeShakingSharedPlugin {
+    apply(compiler) {
+        // @ts-expect-error wait rspack release
+        new compiler.rspack.sharing.TreeShakingSharedPlugin(this._options).apply(compiler);
+    }
+    constructor(options){
+        this.name = PLUGIN_NAME;
+        this._options = options;
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  TreeShakingSharedPlugin: () => (TreeShakingSharedPlugin)
+}, {
+  PLUGIN_NAME: PLUGIN_NAME
+});
+
+exports.PLUGIN_NAME = __webpack_exports__.PLUGIN_NAME;
+exports.TreeShakingSharedPlugin = __webpack_exports__.TreeShakingSharedPlugin;
+for(var __rspack_i in __webpack_exports__) {
+  if(["PLUGIN_NAME","TreeShakingSharedPlugin"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });