@module-federation/metro 0.0.0-next-20250827124348

package/dist/plugin/normalize-options.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeOptions: ()=>normalizeOptions
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+function normalizeOptions(options, { projectRoot, tmpDirPath }) {
+    const shared = getNormalizedShared(options, projectRoot);
+    const shareStrategy = getNormalizedShareStrategy(options);
+    const plugins = getNormalizedPlugins(options, tmpDirPath);
+    return {
+        name: options.name,
+        filename: options.filename ?? external_constants_js_namespaceObject.DEFAULT_ENTRY_FILENAME,
+        remotes: options.remotes ?? {},
+        exposes: options.exposes ?? {},
+        shared,
+        shareStrategy,
+        plugins
+    };
+}
+function getNormalizedShared(options, projectRoot) {
+    const pkg = getProjectPackageJson(projectRoot);
+    const shared = options.shared ?? {};
+    if (!options.exposes) for (const sharedName of Object.keys(shared))shared[sharedName].eager = true;
+    for (const sharedName of Object.keys(shared))if (!shared[sharedName].requiredVersion) {
+        var _pkg_dependencies, _pkg_devDependencies;
+        shared[sharedName].requiredVersion = (null == (_pkg_dependencies = pkg.dependencies) ? void 0 : _pkg_dependencies[sharedName]) || (null == (_pkg_devDependencies = pkg.devDependencies) ? void 0 : _pkg_devDependencies[sharedName]);
+    }
+    if (!shared['react-native/Libraries/Network/RCTNetworking']) {
+        const reactNativeSharedConfig = shared['react-native'];
+        shared['react-native/Libraries/Network/RCTNetworking'] = reactNativeSharedConfig;
+    }
+    return shared;
+}
+function getNormalizedShareStrategy(options) {
+    return options.shareStrategy ?? 'loaded-first';
+}
+function getNormalizedPlugins(options, tmpDirPath) {
+    const plugins = options.plugins ?? [];
+    plugins.unshift(require.resolve('../modules/metroCorePlugin.ts'));
+    return plugins.map((pluginPath)=>external_node_path_default().relative(tmpDirPath, pluginPath));
+}
+function getProjectPackageJson(projectRoot) {
+    const packageJsonPath = external_node_path_default().join(projectRoot, 'package.json');
+    return JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf-8'));
+}
+exports.normalizeOptions = __webpack_exports__.normalizeOptions;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "normalizeOptions"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/normalize-options.mjs

@@ -0,0 +1,46 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { DEFAULT_ENTRY_FILENAME } from "./constants.mjs";
+function normalizeOptions(options, { projectRoot, tmpDirPath }) {
+    const shared = getNormalizedShared(options, projectRoot);
+    const shareStrategy = getNormalizedShareStrategy(options);
+    const plugins = getNormalizedPlugins(options, tmpDirPath);
+    return {
+        name: options.name,
+        filename: options.filename ?? DEFAULT_ENTRY_FILENAME,
+        remotes: options.remotes ?? {},
+        exposes: options.exposes ?? {},
+        shared,
+        shareStrategy,
+        plugins
+    };
+}
+function getNormalizedShared(options, projectRoot) {
+    const pkg = getProjectPackageJson(projectRoot);
+    const shared = options.shared ?? {};
+    if (!options.exposes) for (const sharedName of Object.keys(shared))shared[sharedName].eager = true;
+    for (const sharedName of Object.keys(shared))if (!shared[sharedName].requiredVersion) {
+        var _pkg_dependencies, _pkg_devDependencies;
+        shared[sharedName].requiredVersion = (null == (_pkg_dependencies = pkg.dependencies) ? void 0 : _pkg_dependencies[sharedName]) || (null == (_pkg_devDependencies = pkg.devDependencies) ? void 0 : _pkg_devDependencies[sharedName]);
+    }
+    if (!shared['react-native/Libraries/Network/RCTNetworking']) {
+        const reactNativeSharedConfig = shared['react-native'];
+        shared['react-native/Libraries/Network/RCTNetworking'] = reactNativeSharedConfig;
+    }
+    return shared;
+}
+function getNormalizedShareStrategy(options) {
+    return options.shareStrategy ?? 'loaded-first';
+}
+function getNormalizedPlugins(options, tmpDirPath) {
+    const plugins = options.plugins ?? [];
+    plugins.unshift(require.resolve('../modules/metroCorePlugin.ts'));
+    return plugins.map((pluginPath)=>node_path.relative(tmpDirPath, pluginPath));
+}
+function getProjectPackageJson(projectRoot) {
+    const packageJsonPath = node_path.join(projectRoot, 'package.json');
+    return JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+}
+export { normalizeOptions };

package/dist/plugin/resolver.d.ts

@@ -0,0 +1,25 @@
+import type { CustomResolver } from 'metro-resolver';
+import type { ModuleFederationConfigNormalized } from '../types';
+import type { VirtualModuleManager } from '../utils';
+interface CreateResolveRequestOptions {
+    isRemote: boolean;
+    hacks: {
+        patchHMRClient: boolean;
+        patchInitializeCore: boolean;
+    };
+    paths: {
+        asyncRequire: string;
+        hostEntry: string;
+        initHost: string;
+        originalEntry: string;
+        remoteEntry: string;
+        remoteHMRSetup: string;
+        remoteModuleRegistry: string;
+        projectDir: string;
+        tmpDir: string;
+    };
+    options: ModuleFederationConfigNormalized;
+    vmManager: VirtualModuleManager;
+}
+export declare function createResolveRequest({ vmManager, options, hacks, paths, isRemote, }: CreateResolveRequestOptions): CustomResolver;
+export {};

package/dist/plugin/resolver.js

@@ -0,0 +1,199 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createResolveRequest: ()=>createResolveRequest
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_generators_js_namespaceObject = require("./generators.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+function createResolveRequest({ vmManager, options, hacks, paths, isRemote }) {
+    const hostEntryPathRegex = getEntryPathRegex({
+        entry: paths.hostEntry,
+        projectDir: paths.projectDir
+    });
+    const remoteEntryPathRegex = getEntryPathRegex({
+        entry: paths.remoteEntry,
+        projectDir: paths.projectDir
+    });
+    return function(context, moduleName, platform) {
+        if (moduleName.match(hostEntryPathRegex)) {
+            const hostEntryGenerator = ()=>(0, external_generators_js_namespaceObject.getHostEntryModule)(options, {
+                    originalEntry: paths.originalEntry,
+                    tmpDir: paths.tmpDir
+                });
+            vmManager.registerVirtualModule(paths.hostEntry, hostEntryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.hostEntry
+            };
+        }
+        if (moduleName.match(remoteEntryPathRegex)) {
+            const remoteEntryGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteEntryModule)(options, {
+                    tmpDir: paths.tmpDir,
+                    projectDir: paths.projectDir
+                });
+            vmManager.registerVirtualModule(paths.remoteEntry, remoteEntryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteEntry
+            };
+        }
+        if (moduleName === external_constants_js_namespaceObject.INIT_HOST) {
+            const initHostGenerator = ()=>(0, external_generators_js_namespaceObject.getInitHostModule)(options);
+            vmManager.registerVirtualModule(paths.initHost, initHostGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.initHost
+            };
+        }
+        if (moduleName === external_constants_js_namespaceObject.REMOTE_MODULE_REGISTRY) {
+            const registryGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteModuleRegistryModule)();
+            vmManager.registerVirtualModule(paths.remoteModuleRegistry, registryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteModuleRegistry
+            };
+        }
+        if (moduleName === external_constants_js_namespaceObject.REMOTE_HMR_SETUP) {
+            const remoteHMRSetupGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteHMRSetupModule)();
+            vmManager.registerVirtualModule(paths.remoteHMRSetup, remoteHMRSetupGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteHMRSetup
+            };
+        }
+        if (moduleName === external_constants_js_namespaceObject.ASYNC_REQUIRE) return {
+            type: 'sourceFile',
+            filePath: paths.asyncRequire
+        };
+        if ([
+            paths.initHost
+        ].includes(context.originModulePath)) return context.resolveRequest(context, moduleName, platform);
+        if ([
+            paths.remoteEntry
+        ].includes(context.originModulePath)) {
+            const sharedModule = options.shared[moduleName];
+            if (sharedModule && false === sharedModule.import) {
+                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
+                return {
+                    type: 'sourceFile',
+                    filePath: sharedPath
+                };
+            }
+            return context.resolveRequest(context, moduleName, platform);
+        }
+        for (const remoteName of Object.keys(options.remotes))if (moduleName.startsWith(remoteName + '/')) {
+            const remotePath = getRemoteModulePath(moduleName, paths.tmpDir);
+            const remoteGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(moduleName);
+            vmManager.registerVirtualModule(remotePath, remoteGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: remotePath
+            };
+        }
+        for (const sharedName of Object.keys(options.shared)){
+            const importName = options.shared[sharedName].import || sharedName;
+            if (moduleName === importName) {
+                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
+                const sharedGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(moduleName);
+                vmManager.registerVirtualModule(sharedPath, sharedGenerator);
+                return {
+                    type: 'sourceFile',
+                    filePath: sharedPath
+                };
+            }
+        }
+        if (isRemote && moduleName.endsWith('getDevServer')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = external_constants_js_namespaceObject.GET_DEV_SERVER_REGEX;
+            const to = resolveModule('getDevServer.ts');
+            return replaceModule(from, to)(res);
+        }
+        if ((0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)() && moduleName.endsWith('HMRClient')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = external_constants_js_namespaceObject.HMR_CLIENT_REGEX;
+            const to = resolveModule('HMRClientShim.ts');
+            return replaceModule(from, to)(res);
+        }
+        if (hacks.patchHMRClient && moduleName.endsWith('HMRClient') && context.originModulePath !== resolveModule('HMRClient.ts')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = external_constants_js_namespaceObject.HMR_CLIENT_REGEX;
+            const to = resolveModule('HMRClient.ts');
+            return replaceModule(from, to)(res);
+        }
+        return context.resolveRequest(context, moduleName, platform);
+    };
+}
+function getSharedPath(name, dir) {
+    const sharedModuleName = name.replaceAll('/', '_');
+    const sharedModuleDir = external_node_path_default().join(dir, 'shared');
+    return external_node_path_default().join(sharedModuleDir, `${sharedModuleName}.js`);
+}
+function getRemoteModulePath(name, dir) {
+    const remoteModuleName = name.replaceAll('/', '_');
+    const remoteModuleDir = external_node_path_default().join(dir, 'remote');
+    return external_node_path_default().join(remoteModuleDir, `${remoteModuleName}.js`);
+}
+function resolveModule(moduleName) {
+    return external_node_path_default().resolve(__dirname, `../modules/${moduleName}`);
+}
+function replaceModule(from, to) {
+    return (resolved)=>{
+        if ('sourceFile' === resolved.type && from.test(resolved.filePath)) {
+            if (null === to) return {
+                type: 'empty'
+            };
+            return {
+                type: 'sourceFile',
+                filePath: to
+            };
+        }
+        return resolved;
+    };
+}
+function getEntryPathRegex(paths) {
+    const relativeEntryPath = external_node_path_default().relative(paths.projectDir, paths.entry);
+    const entryName = (0, external_helpers_js_namespaceObject.removeExtension)(relativeEntryPath);
+    return new RegExp(`^\\./${entryName}(\\.js)?$`);
+}
+exports.createResolveRequest = __webpack_exports__.createResolveRequest;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createResolveRequest"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/resolver.mjs

@@ -0,0 +1,160 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
+import { dirname as __webpack_dirname__ } from "node:path";
+import node_path from "node:path";
+import { ASYNC_REQUIRE, GET_DEV_SERVER_REGEX, HMR_CLIENT_REGEX, INIT_HOST, REMOTE_HMR_SETUP, REMOTE_MODULE_REGISTRY } from "./constants.mjs";
+import { getHostEntryModule, getInitHostModule, getRemoteEntryModule, getRemoteHMRSetupModule, getRemoteModule, getRemoteModuleRegistryModule } from "./generators.mjs";
+import { isUsingMFBundleCommand, removeExtension } from "./helpers.mjs";
+var resolver_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+function createResolveRequest({ vmManager, options, hacks, paths, isRemote }) {
+    const hostEntryPathRegex = getEntryPathRegex({
+        entry: paths.hostEntry,
+        projectDir: paths.projectDir
+    });
+    const remoteEntryPathRegex = getEntryPathRegex({
+        entry: paths.remoteEntry,
+        projectDir: paths.projectDir
+    });
+    return function(context, moduleName, platform) {
+        if (moduleName.match(hostEntryPathRegex)) {
+            const hostEntryGenerator = ()=>getHostEntryModule(options, {
+                    originalEntry: paths.originalEntry,
+                    tmpDir: paths.tmpDir
+                });
+            vmManager.registerVirtualModule(paths.hostEntry, hostEntryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.hostEntry
+            };
+        }
+        if (moduleName.match(remoteEntryPathRegex)) {
+            const remoteEntryGenerator = ()=>getRemoteEntryModule(options, {
+                    tmpDir: paths.tmpDir,
+                    projectDir: paths.projectDir
+                });
+            vmManager.registerVirtualModule(paths.remoteEntry, remoteEntryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteEntry
+            };
+        }
+        if (moduleName === INIT_HOST) {
+            const initHostGenerator = ()=>getInitHostModule(options);
+            vmManager.registerVirtualModule(paths.initHost, initHostGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.initHost
+            };
+        }
+        if (moduleName === REMOTE_MODULE_REGISTRY) {
+            const registryGenerator = ()=>getRemoteModuleRegistryModule();
+            vmManager.registerVirtualModule(paths.remoteModuleRegistry, registryGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteModuleRegistry
+            };
+        }
+        if (moduleName === REMOTE_HMR_SETUP) {
+            const remoteHMRSetupGenerator = ()=>getRemoteHMRSetupModule();
+            vmManager.registerVirtualModule(paths.remoteHMRSetup, remoteHMRSetupGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: paths.remoteHMRSetup
+            };
+        }
+        if (moduleName === ASYNC_REQUIRE) return {
+            type: 'sourceFile',
+            filePath: paths.asyncRequire
+        };
+        if ([
+            paths.initHost
+        ].includes(context.originModulePath)) return context.resolveRequest(context, moduleName, platform);
+        if ([
+            paths.remoteEntry
+        ].includes(context.originModulePath)) {
+            const sharedModule = options.shared[moduleName];
+            if (sharedModule && false === sharedModule.import) {
+                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
+                return {
+                    type: 'sourceFile',
+                    filePath: sharedPath
+                };
+            }
+            return context.resolveRequest(context, moduleName, platform);
+        }
+        for (const remoteName of Object.keys(options.remotes))if (moduleName.startsWith(remoteName + '/')) {
+            const remotePath = getRemoteModulePath(moduleName, paths.tmpDir);
+            const remoteGenerator = ()=>getRemoteModule(moduleName);
+            vmManager.registerVirtualModule(remotePath, remoteGenerator);
+            return {
+                type: 'sourceFile',
+                filePath: remotePath
+            };
+        }
+        for (const sharedName of Object.keys(options.shared)){
+            const importName = options.shared[sharedName].import || sharedName;
+            if (moduleName === importName) {
+                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
+                const sharedGenerator = ()=>getRemoteModule(moduleName);
+                vmManager.registerVirtualModule(sharedPath, sharedGenerator);
+                return {
+                    type: 'sourceFile',
+                    filePath: sharedPath
+                };
+            }
+        }
+        if (isRemote && moduleName.endsWith('getDevServer')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = GET_DEV_SERVER_REGEX;
+            const to = resolveModule('getDevServer.ts');
+            return replaceModule(from, to)(res);
+        }
+        if (isUsingMFBundleCommand() && moduleName.endsWith('HMRClient')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = HMR_CLIENT_REGEX;
+            const to = resolveModule('HMRClientShim.ts');
+            return replaceModule(from, to)(res);
+        }
+        if (hacks.patchHMRClient && moduleName.endsWith('HMRClient') && context.originModulePath !== resolveModule('HMRClient.ts')) {
+            const res = context.resolveRequest(context, moduleName, platform);
+            const from = HMR_CLIENT_REGEX;
+            const to = resolveModule('HMRClient.ts');
+            return replaceModule(from, to)(res);
+        }
+        return context.resolveRequest(context, moduleName, platform);
+    };
+}
+function getSharedPath(name, dir) {
+    const sharedModuleName = name.replaceAll('/', '_');
+    const sharedModuleDir = node_path.join(dir, 'shared');
+    return node_path.join(sharedModuleDir, `${sharedModuleName}.js`);
+}
+function getRemoteModulePath(name, dir) {
+    const remoteModuleName = name.replaceAll('/', '_');
+    const remoteModuleDir = node_path.join(dir, 'remote');
+    return node_path.join(remoteModuleDir, `${remoteModuleName}.js`);
+}
+function resolveModule(moduleName) {
+    return node_path.resolve(resolver_dirname, `../modules/${moduleName}`);
+}
+function replaceModule(from, to) {
+    return (resolved)=>{
+        if ('sourceFile' === resolved.type && from.test(resolved.filePath)) {
+            if (null === to) return {
+                type: 'empty'
+            };
+            return {
+                type: 'sourceFile',
+                filePath: to
+            };
+        }
+        return resolved;
+    };
+}
+function getEntryPathRegex(paths) {
+    const relativeEntryPath = node_path.relative(paths.projectDir, paths.entry);
+    const entryName = removeExtension(relativeEntryPath);
+    return new RegExp(`^\\./${entryName}(\\.js)?$`);
+}
+export { createResolveRequest };

package/dist/plugin/rewrite-request.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigT } from 'metro-config';
+type CreateRewriteRequestOptions = {
+    config: ConfigT;
+    originalEntryFilename: string;
+    remoteEntryFilename: string;
+    manifestPath: string;
+    tmpDirPath: string;
+};
+export declare function createRewriteRequest({ config, originalEntryFilename, remoteEntryFilename, manifestPath, tmpDirPath, }: CreateRewriteRequestOptions): (url: string) => string;
+export {};

package/dist/plugin/rewrite-request.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRewriteRequest: ()=>createRewriteRequest
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+function createRewriteRequest({ config, originalEntryFilename, remoteEntryFilename, manifestPath, tmpDirPath }) {
+    const hostEntryName = (0, external_helpers_js_namespaceObject.removeExtension)(originalEntryFilename);
+    const remoteEntryName = (0, external_helpers_js_namespaceObject.removeExtension)(remoteEntryFilename);
+    const relativeTmpDirPath = external_node_path_default().relative(config.projectRoot, tmpDirPath).split(external_node_path_default().sep).join(external_node_path_default().posix.sep);
+    const hostEntryPathRegex = getEntryPathRegex(hostEntryName);
+    const remoteEntryPathRegex = getEntryPathRegex(remoteEntryName);
+    return function(url) {
+        const root = config.projectRoot;
+        const { pathname } = new URL(url, 'protocol://host');
+        if (pathname.match(hostEntryPathRegex)) {
+            const target = `${relativeTmpDirPath}/${hostEntryName}`;
+            return url.replace(hostEntryName, target);
+        }
+        if (pathname.match(remoteEntryPathRegex)) {
+            const target = `${relativeTmpDirPath}/${remoteEntryName}`;
+            return url.replace(remoteEntryName, target);
+        }
+        if (pathname.startsWith(`/${external_constants_js_namespaceObject.MANIFEST_FILENAME}`)) {
+            const target = manifestPath.replace(root, '[metro-project]');
+            return url.replace(external_constants_js_namespaceObject.MANIFEST_FILENAME, target);
+        }
+        if (config.server.rewriteRequestUrl) return config.server.rewriteRequestUrl(url);
+        return url;
+    };
+}
+function getEntryPathRegex(entryFilename) {
+    return new RegExp(`^\\/${entryFilename}(\\.js)?(\\.bundle)$`);
+}
+exports.createRewriteRequest = __webpack_exports__.createRewriteRequest;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createRewriteRequest"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/rewrite-request.mjs

@@ -0,0 +1,34 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_path from "node:path";
+import { MANIFEST_FILENAME } from "./constants.mjs";
+import { removeExtension } from "./helpers.mjs";
+function createRewriteRequest({ config, originalEntryFilename, remoteEntryFilename, manifestPath, tmpDirPath }) {
+    const hostEntryName = removeExtension(originalEntryFilename);
+    const remoteEntryName = removeExtension(remoteEntryFilename);
+    const relativeTmpDirPath = node_path.relative(config.projectRoot, tmpDirPath).split(node_path.sep).join(node_path.posix.sep);
+    const hostEntryPathRegex = getEntryPathRegex(hostEntryName);
+    const remoteEntryPathRegex = getEntryPathRegex(remoteEntryName);
+    return function(url) {
+        const root = config.projectRoot;
+        const { pathname } = new URL(url, 'protocol://host');
+        if (pathname.match(hostEntryPathRegex)) {
+            const target = `${relativeTmpDirPath}/${hostEntryName}`;
+            return url.replace(hostEntryName, target);
+        }
+        if (pathname.match(remoteEntryPathRegex)) {
+            const target = `${relativeTmpDirPath}/${remoteEntryName}`;
+            return url.replace(remoteEntryName, target);
+        }
+        if (pathname.startsWith(`/${MANIFEST_FILENAME}`)) {
+            const target = manifestPath.replace(root, '[metro-project]');
+            return url.replace(MANIFEST_FILENAME, target);
+        }
+        if (config.server.rewriteRequestUrl) return config.server.rewriteRequestUrl(url);
+        return url;
+    };
+}
+function getEntryPathRegex(entryFilename) {
+    return new RegExp(`^\\/${entryFilename}(\\.js)?(\\.bundle)$`);
+}
+export { createRewriteRequest };

package/dist/plugin/serializer.d.ts

@@ -0,0 +1,5 @@
+import type { SerializerConfigT } from 'metro-config';
+import type { ModuleFederationConfigNormalized } from '../types';
+type CustomSerializer = SerializerConfigT['customSerializer'];
+export declare function getModuleFederationSerializer(mfConfig: ModuleFederationConfigNormalized, isUsingMFBundleCommand: boolean): CustomSerializer;
+export {};