@module-federation/metro 0.0.0-next-20250827124348

package/dist/plugin/index.js

@@ -0,0 +1,167 @@
+"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__, {
+    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_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 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_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', "\u2022")} bundle-mf-host` + external_node_util_default().styleText('dim', ' - for bundling a host application\n') + ` ${external_node_util_default().styleText('dim', "\u2022")} 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 manifestPath = (0, external_manifest_js_namespaceObject.createManifest)(options, tmpDirPath);
+    (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;
+    return {
+        ...config,
+        serializer: {
+            ...config.serializer,
+            customSerializer: (0, external_serializer_js_namespaceObject.getModuleFederationSerializer)(options, (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)()),
+            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
+                }
+            })
+        },
+        server: {
+            ...config.server,
+            enhanceMiddleware: vmManager.getMiddleware(),
+            rewriteRequestUrl: (0, external_rewrite_request_js_namespaceObject.createRewriteRequest)({
+                config,
+                originalEntryFilename,
+                remoteEntryFilename,
+                manifestPath,
+                tmpDirPath
+            })
+        }
+    };
+}
+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 __webpack_i__ in __webpack_exports__)if (-1 === [
+    "withModuleFederation"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/index.mjs

@@ -0,0 +1,124 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import node_path from "node:path";
+import node_util from "node:util";
+import { VirtualModuleManager } from "../utils/index.mjs";
+import { createBabelTransformer } from "./babel-transformer.mjs";
+import { isUsingMFBundleCommand, isUsingMFCommand, prepareTmpDir, replaceExtension, stubHostEntry, stubRemoteEntry } from "./helpers.mjs";
+import { createManifest } from "./manifest.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', "\u2022")} bundle-mf-host` + node_util.styleText('dim', ' - for bundling a host application\n') + ` ${node_util.styleText('dim', "\u2022")} 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 manifestPath = createManifest(options, tmpDirPath);
+    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;
+    return {
+        ...config,
+        serializer: {
+            ...config.serializer,
+            customSerializer: getModuleFederationSerializer(options, isUsingMFBundleCommand()),
+            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
+                }
+            })
+        },
+        server: {
+            ...config.server,
+            enhanceMiddleware: vmManager.getMiddleware(),
+            rewriteRequestUrl: createRewriteRequest({
+                config,
+                originalEntryFilename,
+                remoteEntryFilename,
+                manifestPath,
+                tmpDirPath
+            })
+        }
+    };
+}
+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.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+export declare function createManifest(options: ModuleFederationConfigNormalized, mfMetroPath: string): string;
+export declare const updateManifest: (manifestPath: string, options: ModuleFederationConfigNormalized) => string;

package/dist/plugin/manifest.js

@@ -0,0 +1,146 @@
+"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__, {
+    createManifest: ()=>createManifest,
+    updateManifest: ()=>updateManifest
+});
+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 createManifest(options, mfMetroPath) {
+    const manifestPath = external_node_path_default().join(mfMetroPath, external_constants_js_namespaceObject.MANIFEST_FILENAME);
+    const manifest = generateManifest(options);
+    external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+const updateManifest = (manifestPath, options)=>{
+    const manifest = generateManifest(options);
+    external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+};
+function generateManifest(config) {
+    return {
+        id: config.name,
+        name: config.name,
+        metaData: generateMetaData(config),
+        exposes: generateExposes(config),
+        remotes: generateRemotes(config),
+        shared: generateShared(config)
+    };
+}
+function generateMetaData(config) {
+    return {
+        name: config.name,
+        type: 'app',
+        buildInfo: {
+            buildVersion: '1.0.0',
+            buildName: config.name
+        },
+        remoteEntry: {
+            name: config.filename,
+            path: '',
+            type: 'global'
+        },
+        types: {
+            path: '',
+            name: '',
+            api: '',
+            zip: ''
+        },
+        globalName: config.name,
+        pluginVersion: '',
+        publicPath: 'auto'
+    };
+}
+function generateExposes(config) {
+    return Object.keys(config.exposes).map((expose)=>{
+        const formatKey = expose.replace('./', '');
+        const assets = getEmptyAssets();
+        assets.js.sync.push(config.exposes[expose]);
+        return {
+            id: `${config.name}:${formatKey}`,
+            name: formatKey,
+            path: expose,
+            assets
+        };
+    });
+}
+function generateRemotes(config) {
+    return Object.keys(config.remotes).map((remote)=>({
+            federationContainerName: config.remotes[remote],
+            moduleName: remote,
+            alias: remote,
+            entry: '*'
+        }));
+}
+function generateShared(config) {
+    return Object.keys(config.shared).map((sharedName)=>{
+        const assets = getEmptyAssets();
+        if (config.shared[sharedName].eager) assets.js.sync.push(config.filename);
+        else if (false !== config.shared[sharedName].import) assets.js.sync.push(`shared/${sharedName}.bundle`);
+        return {
+            id: sharedName,
+            name: sharedName,
+            version: config.shared[sharedName].version,
+            requiredVersion: config.shared[sharedName].requiredVersion,
+            singleton: config.shared[sharedName].singleton,
+            hash: '',
+            assets
+        };
+    });
+}
+function getEmptyAssets() {
+    return {
+        js: {
+            sync: [],
+            async: []
+        },
+        css: {
+            sync: [],
+            async: []
+        }
+    };
+}
+exports.createManifest = __webpack_exports__.createManifest;
+exports.updateManifest = __webpack_exports__.updateManifest;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createManifest",
+    "updateManifest"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/manifest.mjs

@@ -0,0 +1,100 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { MANIFEST_FILENAME } from "./constants.mjs";
+function createManifest(options, mfMetroPath) {
+    const manifestPath = node_path.join(mfMetroPath, MANIFEST_FILENAME);
+    const manifest = generateManifest(options);
+    node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+const updateManifest = (manifestPath, options)=>{
+    const manifest = generateManifest(options);
+    node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+};
+function generateManifest(config) {
+    return {
+        id: config.name,
+        name: config.name,
+        metaData: generateMetaData(config),
+        exposes: generateExposes(config),
+        remotes: generateRemotes(config),
+        shared: generateShared(config)
+    };
+}
+function generateMetaData(config) {
+    return {
+        name: config.name,
+        type: 'app',
+        buildInfo: {
+            buildVersion: '1.0.0',
+            buildName: config.name
+        },
+        remoteEntry: {
+            name: config.filename,
+            path: '',
+            type: 'global'
+        },
+        types: {
+            path: '',
+            name: '',
+            api: '',
+            zip: ''
+        },
+        globalName: config.name,
+        pluginVersion: '',
+        publicPath: 'auto'
+    };
+}
+function generateExposes(config) {
+    return Object.keys(config.exposes).map((expose)=>{
+        const formatKey = expose.replace('./', '');
+        const assets = getEmptyAssets();
+        assets.js.sync.push(config.exposes[expose]);
+        return {
+            id: `${config.name}:${formatKey}`,
+            name: formatKey,
+            path: expose,
+            assets
+        };
+    });
+}
+function generateRemotes(config) {
+    return Object.keys(config.remotes).map((remote)=>({
+            federationContainerName: config.remotes[remote],
+            moduleName: remote,
+            alias: remote,
+            entry: '*'
+        }));
+}
+function generateShared(config) {
+    return Object.keys(config.shared).map((sharedName)=>{
+        const assets = getEmptyAssets();
+        if (config.shared[sharedName].eager) assets.js.sync.push(config.filename);
+        else if (false !== config.shared[sharedName].import) assets.js.sync.push(`shared/${sharedName}.bundle`);
+        return {
+            id: sharedName,
+            name: sharedName,
+            version: config.shared[sharedName].version,
+            requiredVersion: config.shared[sharedName].requiredVersion,
+            singleton: config.shared[sharedName].singleton,
+            hash: '',
+            assets
+        };
+    });
+}
+function getEmptyAssets() {
+    return {
+        js: {
+            sync: [],
+            async: []
+        },
+        css: {
+            sync: [],
+            async: []
+        }
+    };
+}
+export { createManifest, updateManifest };

package/dist/plugin/normalize-extra-options.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleFederationExtraOptions } from '../types';
+export declare function normalizeExtraOptions(extraOptions?: ModuleFederationExtraOptions): {
+    flags: {
+        unstable_patchHMRClient: boolean;
+        unstable_patchInitializeCore: boolean;
+        unstable_patchRuntimeRequire: boolean;
+    };
+};

package/dist/plugin/normalize-extra-options.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    normalizeExtraOptions: ()=>normalizeExtraOptions
+});
+function normalizeExtraOptions(extraOptions) {
+    return {
+        ...extraOptions,
+        flags: {
+            unstable_patchHMRClient: false,
+            unstable_patchInitializeCore: false,
+            unstable_patchRuntimeRequire: false,
+            ...null == extraOptions ? void 0 : extraOptions.flags
+        }
+    };
+}
+exports.normalizeExtraOptions = __webpack_exports__.normalizeExtraOptions;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "normalizeExtraOptions"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/normalize-extra-options.mjs

@@ -0,0 +1,14 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+function normalizeExtraOptions(extraOptions) {
+    return {
+        ...extraOptions,
+        flags: {
+            unstable_patchHMRClient: false,
+            unstable_patchInitializeCore: false,
+            unstable_patchRuntimeRequire: false,
+            ...null == extraOptions ? void 0 : extraOptions.flags
+        }
+    };
+}
+export { normalizeExtraOptions };

package/dist/plugin/normalize-options.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleFederationConfig, ModuleFederationConfigNormalized } from '../types';
+interface ProjectConfig {
+    projectRoot: string;
+    tmpDirPath: string;
+}
+export declare function normalizeOptions(options: ModuleFederationConfig, { projectRoot, tmpDirPath }: ProjectConfig): ModuleFederationConfigNormalized;
+export {};