@module-federation/metro 0.0.0-chore-bump-node-22-20260710161714

package/dist/plugin/helpers.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { TMP_DIR_NAME } from "./constants.mjs";
+function isUsingMFCommand(command = process.argv[2]) {
+    const allowedCommands = [
+        'start',
+        'bundle-mf-host',
+        'bundle-mf-remote'
+    ];
+    return allowedCommands.includes(command);
+}
+function isUsingMFBundleCommand(command = process.argv[2]) {
+    const allowedCommands = [
+        'bundle-mf-host',
+        'bundle-mf-remote'
+    ];
+    return allowedCommands.includes(command);
+}
+function replaceExtension(filepath, extension) {
+    const separatorIndex = Math.max(filepath.lastIndexOf('/'), filepath.lastIndexOf('\\'));
+    const dotIndex = filepath.lastIndexOf('.');
+    const extensionStart = dotIndex > separatorIndex + 1 ? dotIndex : filepath.length;
+    return `${filepath.slice(0, extensionStart)}${extension}`;
+}
+function removeExtension(filepath) {
+    return replaceExtension(filepath, '');
+}
+function stubHostEntry(hostEntryPath) {
+    const stub = '// host entry stub';
+    node_fs.mkdirSync(node_path.dirname(hostEntryPath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(hostEntryPath, stub, 'utf-8');
+}
+function stubRemoteEntry(remoteEntryPath) {
+    const stub = '// remote entry stub';
+    node_fs.mkdirSync(node_path.dirname(remoteEntryPath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(remoteEntryPath, stub, 'utf-8');
+}
+function prepareTmpDir(projectRootPath) {
+    const nodeModulesPath = node_path.resolve(projectRootPath, 'node_modules');
+    const tmpDirPath = node_path.join(nodeModulesPath, TMP_DIR_NAME);
+    node_fs.rmSync(tmpDirPath, {
+        recursive: true,
+        force: true
+    });
+    node_fs.mkdirSync(tmpDirPath, {
+        recursive: true
+    });
+    return tmpDirPath;
+}
+function toPosixPath(value) {
+    return value.replaceAll('\\', '/');
+}
+export { isUsingMFBundleCommand, isUsingMFCommand, prepareTmpDir, removeExtension, replaceExtension, stubHostEntry, stubRemoteEntry, toPosixPath };

package/dist/plugin/index.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigT } from 'metro-config';
+import type { ModuleFederationConfig, ModuleFederationConfigNormalized, ModuleFederationExtraOptions } from '../types';
+import type { FederatedTypesMeta } from '../utils/federated-remote-types';
+declare global {
+    var __METRO_FEDERATION_CONFIG: ModuleFederationConfigNormalized;
+    var __METRO_FEDERATION_ORIGINAL_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_REMOTE_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_MANIFEST_PATH: string | undefined;
+    var __METRO_FEDERATION_DTS_ASSETS: FederatedTypesMeta | undefined;
+}
+export declare function withModuleFederation(config: ConfigT, federationOptions: ModuleFederationConfig, extraOptions?: ModuleFederationExtraOptions): ConfigT;

package/dist/plugin/index.js

@@ -0,0 +1,219 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    withModuleFederation: ()=>withModuleFederation
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_util_namespaceObject = require("node:util");
+var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+const index_js_namespaceObject = require("../utils/index.js");
+const federated_remote_types_js_namespaceObject = require("../utils/federated-remote-types.js");
+const external_babel_transformer_js_namespaceObject = require("./babel-transformer.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+const external_manifest_middleware_js_namespaceObject = require("./manifest-middleware.js");
+const external_normalize_extra_options_js_namespaceObject = require("./normalize-extra-options.js");
+const external_normalize_options_js_namespaceObject = require("./normalize-options.js");
+const external_resolver_js_namespaceObject = require("./resolver.js");
+const external_rewrite_request_js_namespaceObject = require("./rewrite-request.js");
+const external_serializer_js_namespaceObject = require("./serializer.js");
+const external_validate_options_js_namespaceObject = require("./validate-options.js");
+function withModuleFederation(config, federationOptions, extraOptions) {
+    if ((0, external_helpers_js_namespaceObject.isUsingMFCommand)()) return augmentConfig(config, federationOptions, extraOptions);
+    console.warn(external_node_util_default().styleText('yellow', 'Warning: Module Federation build is disabled for this command.\n') + external_node_util_default().styleText('yellow', 'To enable Module Federation, please use one of the dedicated bundle commands:\n') + ` ${external_node_util_default().styleText('dim', '•')} bundle-mf-host` + external_node_util_default().styleText('dim', ' - for bundling a host application\n') + ` ${external_node_util_default().styleText('dim', '•')} bundle-mf-remote` + external_node_util_default().styleText('dim', ' - for bundling a remote application\n'));
+    return config;
+}
+function augmentConfig(config, federationOptions, extraOptions) {
+    const isHost = !federationOptions.exposes;
+    const isRemote = !isHost;
+    const tmpDirPath = (0, external_helpers_js_namespaceObject.prepareTmpDir)(config.projectRoot);
+    (0, external_validate_options_js_namespaceObject.validateOptions)(federationOptions);
+    const options = (0, external_normalize_options_js_namespaceObject.normalizeOptions)(federationOptions, {
+        projectRoot: config.projectRoot,
+        tmpDirPath
+    });
+    const { flags } = (0, external_normalize_extra_options_js_namespaceObject.normalizeExtraOptions)(extraOptions);
+    const vmManager = new index_js_namespaceObject.VirtualModuleManager(config);
+    const { originalEntryFilename, originalEntryPath } = getOriginalEntry(config.projectRoot, 'index.js');
+    const hostEntryFilename = originalEntryFilename;
+    const hostEntryPath = external_node_path_default().resolve(tmpDirPath, hostEntryFilename);
+    const remoteEntryFilename = (0, external_helpers_js_namespaceObject.replaceExtension)(options.filename, '.js');
+    const remoteEntryPath = external_node_path_default().resolve(tmpDirPath, remoteEntryFilename);
+    const initHostPath = external_node_path_default().resolve(tmpDirPath, 'init-host.js');
+    const remoteHMRSetupPath = external_node_path_default().resolve(tmpDirPath, 'remote-hmr.js');
+    const remoteModuleRegistryPath = external_node_path_default().resolve(tmpDirPath, 'remote-module-registry.js');
+    const asyncRequirePath = require.resolve('../modules/asyncRequire.ts');
+    const babelTransformerPath = (0, external_babel_transformer_js_namespaceObject.createBabelTransformer)({
+        blacklistedPaths: [
+            initHostPath,
+            remoteEntryPath
+        ],
+        federationConfig: options,
+        originalBabelTransformerPath: config.transformer.babelTransformerPath,
+        tmpDirPath: tmpDirPath,
+        enableInitializeCorePatching: flags.unstable_patchInitializeCore,
+        enableRuntimeRequirePatching: flags.unstable_patchRuntimeRequire
+    });
+    const manifestOptions = {
+        projectRoot: config.projectRoot,
+        target: (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)() ? 'build' : 'development',
+        tmpDirPath
+    };
+    const manifestPath = (0, external_manifest_js_namespaceObject.createManifest)(options, tmpDirPath, manifestOptions);
+    (0, external_helpers_js_namespaceObject.stubHostEntry)(hostEntryPath);
+    (0, external_helpers_js_namespaceObject.stubRemoteEntry)(remoteEntryPath);
+    global.__METRO_FEDERATION_CONFIG = options;
+    global.__METRO_FEDERATION_HOST_ENTRY_PATH = hostEntryPath;
+    global.__METRO_FEDERATION_REMOTE_ENTRY_PATH = remoteEntryPath;
+    global.__METRO_FEDERATION_MANIFEST_PATH = manifestPath;
+    global.__METRO_FEDERATION_DTS_ASSETS = void 0;
+    maybeGenerateRemoteTypesForStart({
+        isRemote,
+        options,
+        projectRoot: config.projectRoot,
+        tmpDirPath,
+        manifestPath
+    });
+    return {
+        ...config,
+        serializer: {
+            ...config.serializer,
+            customSerializer: (0, external_serializer_js_namespaceObject.getModuleFederationSerializer)(options, (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)(), manifestPath, manifestOptions),
+            getModulesRunBeforeMainModule: (entryFilePath)=>{
+                if (flags.unstable_patchInitializeCore) return config.serializer.getModulesRunBeforeMainModule(entryFilePath);
+                if (isRemote) return [];
+                return [
+                    initHostPath,
+                    ...config.serializer.getModulesRunBeforeMainModule(entryFilePath)
+                ];
+            },
+            getRunModuleStatement: (moduleId)=>`${options.name}__r(${JSON.stringify(moduleId)});`,
+            getPolyfills: (options)=>isHost ? config.serializer.getPolyfills(options) : []
+        },
+        transformer: {
+            ...config.transformer,
+            globalPrefix: options.name,
+            babelTransformerPath: babelTransformerPath,
+            getTransformOptions: vmManager.getTransformOptions()
+        },
+        resolver: {
+            ...config.resolver,
+            resolveRequest: (0, external_resolver_js_namespaceObject.createResolveRequest)({
+                isRemote,
+                vmManager,
+                options,
+                paths: {
+                    asyncRequire: asyncRequirePath,
+                    originalEntry: originalEntryPath,
+                    hostEntry: hostEntryPath,
+                    initHost: initHostPath,
+                    remoteModuleRegistry: remoteModuleRegistryPath,
+                    remoteHMRSetup: remoteHMRSetupPath,
+                    remoteEntry: remoteEntryPath,
+                    projectDir: config.projectRoot,
+                    tmpDir: tmpDirPath
+                },
+                hacks: {
+                    patchHMRClient: flags.unstable_patchHMRClient,
+                    patchInitializeCore: flags.unstable_patchInitializeCore
+                },
+                customResolver: config.resolver.resolveRequest
+            })
+        },
+        server: {
+            ...config.server,
+            enhanceMiddleware: (middleware, metroServer)=>{
+                const manifestMiddleware = (0, external_manifest_middleware_js_namespaceObject.createManifestMiddleware)({
+                    federationConfig: options,
+                    projectRoot: config.projectRoot,
+                    remoteEntryPath,
+                    tmpDirPath,
+                    vmManager
+                })(middleware, metroServer);
+                return vmManager.getMiddleware()(manifestMiddleware, metroServer);
+            },
+            rewriteRequestUrl: (0, external_rewrite_request_js_namespaceObject.createRewriteRequest)({
+                config,
+                originalEntryFilename,
+                remoteEntryFilename,
+                manifestPath,
+                tmpDirPath,
+                getDtsAssetNames: ()=>global.__METRO_FEDERATION_DTS_ASSETS
+            })
+        }
+    };
+}
+function maybeGenerateRemoteTypesForStart(opts) {
+    if ('start' !== process.argv[2]) return;
+    if (!opts.isRemote || false === opts.options.dts) return;
+    (async ()=>{
+        try {
+            const typesMeta = await (0, federated_remote_types_js_namespaceObject.maybeGenerateFederatedRemoteTypes)({
+                federationConfig: opts.options,
+                projectRoot: opts.projectRoot,
+                outputDir: opts.tmpDirPath,
+                logger: console
+            });
+            if (!typesMeta) return;
+            global.__METRO_FEDERATION_DTS_ASSETS = typesMeta;
+            const manifest = JSON.parse(await external_node_fs_namespaceObject.promises.readFile(opts.manifestPath, 'utf-8'));
+            (0, federated_remote_types_js_namespaceObject.applyTypesMetaToManifest)(manifest, typesMeta);
+            await external_node_fs_namespaceObject.promises.writeFile(opts.manifestPath, JSON.stringify(manifest, void 0, 2), 'utf-8');
+        } catch (error) {
+            console.warn(`${external_node_util_default().styleText('yellow', 'Failed to generate federated types for dev server:')}\n${String(error)}`);
+        }
+    })();
+}
+function getOriginalEntry(projectRoot, entryFilename) {
+    const originalEntryFilename = external_node_path_default().basename(global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH ?? entryFilename);
+    const originalEntryPath = external_node_path_default().resolve(projectRoot, global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH ?? entryFilename);
+    return {
+        originalEntryFilename,
+        originalEntryPath
+    };
+}
+exports.withModuleFederation = __webpack_exports__.withModuleFederation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "withModuleFederation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/index.mjs

@@ -0,0 +1,172 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import node_path from "node:path";
+import { promises } from "node:fs";
+import node_util from "node:util";
+import { VirtualModuleManager } from "../utils/index.mjs";
+import { applyTypesMetaToManifest, maybeGenerateFederatedRemoteTypes } from "../utils/federated-remote-types.mjs";
+import { createBabelTransformer } from "./babel-transformer.mjs";
+import { isUsingMFBundleCommand, isUsingMFCommand, prepareTmpDir, replaceExtension, stubHostEntry, stubRemoteEntry } from "./helpers.mjs";
+import { createManifest } from "./manifest.mjs";
+import { createManifestMiddleware } from "./manifest-middleware.mjs";
+import { normalizeExtraOptions } from "./normalize-extra-options.mjs";
+import { normalizeOptions } from "./normalize-options.mjs";
+import { createResolveRequest } from "./resolver.mjs";
+import { createRewriteRequest } from "./rewrite-request.mjs";
+import { getModuleFederationSerializer } from "./serializer.mjs";
+import { validateOptions } from "./validate-options.mjs";
+function withModuleFederation(config, federationOptions, extraOptions) {
+    if (isUsingMFCommand()) return augmentConfig(config, federationOptions, extraOptions);
+    console.warn(node_util.styleText('yellow', 'Warning: Module Federation build is disabled for this command.\n') + node_util.styleText('yellow', 'To enable Module Federation, please use one of the dedicated bundle commands:\n') + ` ${node_util.styleText('dim', '•')} bundle-mf-host` + node_util.styleText('dim', ' - for bundling a host application\n') + ` ${node_util.styleText('dim', '•')} bundle-mf-remote` + node_util.styleText('dim', ' - for bundling a remote application\n'));
+    return config;
+}
+function augmentConfig(config, federationOptions, extraOptions) {
+    const isHost = !federationOptions.exposes;
+    const isRemote = !isHost;
+    const tmpDirPath = prepareTmpDir(config.projectRoot);
+    validateOptions(federationOptions);
+    const options = normalizeOptions(federationOptions, {
+        projectRoot: config.projectRoot,
+        tmpDirPath
+    });
+    const { flags } = normalizeExtraOptions(extraOptions);
+    const vmManager = new VirtualModuleManager(config);
+    const { originalEntryFilename, originalEntryPath } = getOriginalEntry(config.projectRoot, 'index.js');
+    const hostEntryFilename = originalEntryFilename;
+    const hostEntryPath = node_path.resolve(tmpDirPath, hostEntryFilename);
+    const remoteEntryFilename = replaceExtension(options.filename, '.js');
+    const remoteEntryPath = node_path.resolve(tmpDirPath, remoteEntryFilename);
+    const initHostPath = node_path.resolve(tmpDirPath, 'init-host.js');
+    const remoteHMRSetupPath = node_path.resolve(tmpDirPath, 'remote-hmr.js');
+    const remoteModuleRegistryPath = node_path.resolve(tmpDirPath, 'remote-module-registry.js');
+    const asyncRequirePath = require.resolve('../modules/asyncRequire.ts');
+    const babelTransformerPath = createBabelTransformer({
+        blacklistedPaths: [
+            initHostPath,
+            remoteEntryPath
+        ],
+        federationConfig: options,
+        originalBabelTransformerPath: config.transformer.babelTransformerPath,
+        tmpDirPath: tmpDirPath,
+        enableInitializeCorePatching: flags.unstable_patchInitializeCore,
+        enableRuntimeRequirePatching: flags.unstable_patchRuntimeRequire
+    });
+    const manifestOptions = {
+        projectRoot: config.projectRoot,
+        target: isUsingMFBundleCommand() ? 'build' : 'development',
+        tmpDirPath
+    };
+    const manifestPath = createManifest(options, tmpDirPath, manifestOptions);
+    stubHostEntry(hostEntryPath);
+    stubRemoteEntry(remoteEntryPath);
+    global.__METRO_FEDERATION_CONFIG = options;
+    global.__METRO_FEDERATION_HOST_ENTRY_PATH = hostEntryPath;
+    global.__METRO_FEDERATION_REMOTE_ENTRY_PATH = remoteEntryPath;
+    global.__METRO_FEDERATION_MANIFEST_PATH = manifestPath;
+    global.__METRO_FEDERATION_DTS_ASSETS = void 0;
+    maybeGenerateRemoteTypesForStart({
+        isRemote,
+        options,
+        projectRoot: config.projectRoot,
+        tmpDirPath,
+        manifestPath
+    });
+    return {
+        ...config,
+        serializer: {
+            ...config.serializer,
+            customSerializer: getModuleFederationSerializer(options, isUsingMFBundleCommand(), manifestPath, manifestOptions),
+            getModulesRunBeforeMainModule: (entryFilePath)=>{
+                if (flags.unstable_patchInitializeCore) return config.serializer.getModulesRunBeforeMainModule(entryFilePath);
+                if (isRemote) return [];
+                return [
+                    initHostPath,
+                    ...config.serializer.getModulesRunBeforeMainModule(entryFilePath)
+                ];
+            },
+            getRunModuleStatement: (moduleId)=>`${options.name}__r(${JSON.stringify(moduleId)});`,
+            getPolyfills: (options)=>isHost ? config.serializer.getPolyfills(options) : []
+        },
+        transformer: {
+            ...config.transformer,
+            globalPrefix: options.name,
+            babelTransformerPath: babelTransformerPath,
+            getTransformOptions: vmManager.getTransformOptions()
+        },
+        resolver: {
+            ...config.resolver,
+            resolveRequest: createResolveRequest({
+                isRemote,
+                vmManager,
+                options,
+                paths: {
+                    asyncRequire: asyncRequirePath,
+                    originalEntry: originalEntryPath,
+                    hostEntry: hostEntryPath,
+                    initHost: initHostPath,
+                    remoteModuleRegistry: remoteModuleRegistryPath,
+                    remoteHMRSetup: remoteHMRSetupPath,
+                    remoteEntry: remoteEntryPath,
+                    projectDir: config.projectRoot,
+                    tmpDir: tmpDirPath
+                },
+                hacks: {
+                    patchHMRClient: flags.unstable_patchHMRClient,
+                    patchInitializeCore: flags.unstable_patchInitializeCore
+                },
+                customResolver: config.resolver.resolveRequest
+            })
+        },
+        server: {
+            ...config.server,
+            enhanceMiddleware: (middleware, metroServer)=>{
+                const manifestMiddleware = createManifestMiddleware({
+                    federationConfig: options,
+                    projectRoot: config.projectRoot,
+                    remoteEntryPath,
+                    tmpDirPath,
+                    vmManager
+                })(middleware, metroServer);
+                return vmManager.getMiddleware()(manifestMiddleware, metroServer);
+            },
+            rewriteRequestUrl: createRewriteRequest({
+                config,
+                originalEntryFilename,
+                remoteEntryFilename,
+                manifestPath,
+                tmpDirPath,
+                getDtsAssetNames: ()=>global.__METRO_FEDERATION_DTS_ASSETS
+            })
+        }
+    };
+}
+function maybeGenerateRemoteTypesForStart(opts) {
+    if ('start' !== process.argv[2]) return;
+    if (!opts.isRemote || false === opts.options.dts) return;
+    (async ()=>{
+        try {
+            const typesMeta = await maybeGenerateFederatedRemoteTypes({
+                federationConfig: opts.options,
+                projectRoot: opts.projectRoot,
+                outputDir: opts.tmpDirPath,
+                logger: console
+            });
+            if (!typesMeta) return;
+            global.__METRO_FEDERATION_DTS_ASSETS = typesMeta;
+            const manifest = JSON.parse(await promises.readFile(opts.manifestPath, 'utf-8'));
+            applyTypesMetaToManifest(manifest, typesMeta);
+            await promises.writeFile(opts.manifestPath, JSON.stringify(manifest, void 0, 2), 'utf-8');
+        } catch (error) {
+            console.warn(`${node_util.styleText('yellow', 'Failed to generate federated types for dev server:')}\n${String(error)}`);
+        }
+    })();
+}
+function getOriginalEntry(projectRoot, entryFilename) {
+    const originalEntryFilename = node_path.basename(global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH ?? entryFilename);
+    const originalEntryPath = node_path.resolve(projectRoot, global.__METRO_FEDERATION_ORIGINAL_ENTRY_PATH ?? entryFilename);
+    return {
+        originalEntryFilename,
+        originalEntryPath
+    };
+}
+export { withModuleFederation };

package/dist/plugin/manifest-middleware.d.ts

@@ -0,0 +1,12 @@
+import type { ServerConfigT } from 'metro-config';
+import type { ModuleFederationConfigNormalized } from '../types';
+import type { VirtualModuleManager } from '../utils';
+type ManifestMiddlewareOptions = {
+    federationConfig: ModuleFederationConfigNormalized;
+    projectRoot: string;
+    remoteEntryPath: string;
+    tmpDirPath: string;
+    vmManager: Pick<VirtualModuleManager, 'registerVirtualModule'>;
+};
+export declare function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager, }: ManifestMiddlewareOptions): NonNullable<ServerConfigT['enhanceMiddleware']>;
+export {};