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

package/dist/plugin/serializer.js

@@ -0,0 +1,191 @@
+"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__, {
+    getModuleFederationSerializer: ()=>getModuleFederationSerializer
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const errors_js_namespaceObject = require("../utils/errors.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+const metro_compat_js_namespaceObject = require("../utils/metro-compat.js");
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand, manifestPath, manifestOptions) {
+    const bundleHashes = new Map();
+    return async (entryPoint, preModules, graph, options)=>{
+        const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
+        const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        let code;
+        if (true === options.runModule) {
+            const finalPreModules = [
+                getEarlyShared(syncSharedModules),
+                getEarlyRemotes(syncRemoteModules),
+                ...preModules
+            ];
+            code = getBundleCode(entryPoint, finalPreModules, graph, options);
+        } else if (isProjectSource(entryPoint, options.projectRoot)) {
+            const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
+            const finalPreModules = [
+                getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
+                getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
+            ];
+            if (false === options.modulesOnly) finalPreModules.push(...preModules);
+            const finalOptions = {
+                ...options,
+                modulesOnly: false
+            };
+            code = getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        } else code = getBundleCode(entryPoint, preModules, graph, options);
+        if (manifestPath) {
+            (0, external_manifest_js_namespaceObject.recordBundleHash)(bundleHashes, code, entryPoint, options.projectRoot, mfConfig);
+            (0, external_manifest_js_namespaceObject.updateManifest)(manifestPath, mfConfig, bundleHashes, manifestOptions);
+        }
+        return code;
+    };
+}
+function collectSyncRemoteModules(graph, _remotes) {
+    const remotes = new Set(Object.keys(_remotes));
+    const syncRemoteModules = new Set();
+    for (const [, module] of graph.dependencies)for (const dependency of module.dependencies.values()){
+        if (null !== dependency.data.data.asyncType) continue;
+        const remoteCandidate = dependency.data.name.split('/')[0];
+        const isValidCandidate = remoteCandidate.length < dependency.data.name.length;
+        if (isValidCandidate && remotes.has(remoteCandidate)) syncRemoteModules.add(dependency.data.name);
+    }
+    return Array.from(syncRemoteModules);
+}
+function collectSyncSharedModules(graph, _shared) {
+    const sharedImports = new Set(Object.keys(_shared).map((sharedName)=>_shared[sharedName].import || sharedName));
+    const syncSharedModules = new Set([
+        'react',
+        'react-native'
+    ]);
+    for (const [, module] of graph.dependencies)for (const dependency of module.dependencies.values())if (null === dependency.data.data.asyncType) {
+        if (!module.path.endsWith('init-host.js')) {
+            if (sharedImports.has(dependency.data.name)) syncSharedModules.add(dependency.data.name);
+        }
+    }
+    return Array.from(syncSharedModules);
+}
+function getFederationSharedDependenciesNamespace(scope) {
+    return `globalThis.__FEDERATION__.__NATIVE__["${scope}"].deps.shared`;
+}
+function getFederationRemotesDependenciesNamespace(scope) {
+    return `globalThis.__FEDERATION__.__NATIVE__["${scope}"].deps.remotes`;
+}
+function getSyncShared(shared, entry, scope) {
+    const namespace = getFederationSharedDependenciesNamespace(scope);
+    const code = `${namespace}["${entry}"]=${JSON.stringify(shared)};`;
+    return generateVirtualModule('__required_shared__', code);
+}
+function getSyncRemotes(remotes, entry, scope) {
+    const namespace = getFederationRemotesDependenciesNamespace(scope);
+    const code = `${namespace}["${entry}"]=${JSON.stringify(remotes)};`;
+    return generateVirtualModule('__required_remotes__', code);
+}
+function getEarlyShared(shared) {
+    const code = `var __EARLY_SHARED__=${JSON.stringify(shared)};`;
+    return generateVirtualModule('__early_shared__', code);
+}
+function getEarlyRemotes(remotes) {
+    const code = `var __EARLY_REMOTES__=${JSON.stringify(remotes)};`;
+    return generateVirtualModule('__early_remotes__', code);
+}
+function generateVirtualModule(name, code) {
+    return {
+        dependencies: new Map(),
+        getSource: ()=>Buffer.from(code),
+        inverseDependencies: new metro_compat_js_namespaceObject.CountingSet(),
+        path: name,
+        output: [
+            {
+                type: "js/script/virtual",
+                data: {
+                    code,
+                    lineCount: 1,
+                    map: []
+                }
+            }
+        ]
+    };
+}
+function isProjectSource(entryPoint, projectRoot) {
+    const relativePath = external_node_path_default().relative(projectRoot, entryPoint);
+    return !relativePath.startsWith('..') && !relativePath.startsWith('node_modules');
+}
+function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand) {
+    const relativeEntryPath = external_node_path_default().relative(projectRoot, entryPoint);
+    const normalizedRelativeEntryPath = normalizeEntryPath(relativeEntryPath);
+    if (!isUsingMFBundleCommand) return removePathExtension(normalizedRelativeEntryPath);
+    const exposeEntries = Object.entries(exposes).map(([exposeKey, exposePath])=>({
+            exposeKey,
+            normalizedExposePath: normalizeEntryPath(exposePath)
+        }));
+    const exactMatch = exposeEntries.find(({ normalizedExposePath })=>normalizedExposePath === normalizedRelativeEntryPath);
+    const extensionlessMatch = exposeEntries.find(({ normalizedExposePath })=>removePathExtension(normalizedExposePath) === removePathExtension(normalizedRelativeEntryPath));
+    const exposedMatchedKey = exactMatch?.exposeKey ?? extensionlessMatch?.exposeKey;
+    if (exposedMatchedKey) {
+        let exposedName = exposedMatchedKey;
+        if (exposedName.startsWith('./')) exposedName = exposedName.slice(2);
+        return `exposed/${exposedName}`;
+    }
+    throw new errors_js_namespaceObject.ConfigError(`Unable to handle entry point: ${relativeEntryPath}. Expected to match an entrypoint with one of the exposed keys, but failed. This is most likely a configuration error. If you believe this is not a configuration issue, please report it as a bug. Debug info: entryPoint="${entryPoint}", projectRoot="${projectRoot}", exposesKeys=[${Object.keys(exposes).join(', ')}]`);
+}
+function normalizeEntryPath(value) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(value));
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function removePathExtension(value) {
+    const parsed = external_node_path_default().posix.parse(value);
+    return external_node_path_default().posix.format({
+        dir: parsed.dir,
+        name: parsed.name,
+        ext: ''
+    });
+}
+function getBundleCode(entryPoint, preModules, graph, options) {
+    const { code } = (0, metro_compat_js_namespaceObject.bundleToString)((0, metro_compat_js_namespaceObject.baseJSBundle)(entryPoint, preModules, graph, options));
+    return code;
+}
+exports.getModuleFederationSerializer = __webpack_exports__.getModuleFederationSerializer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getModuleFederationSerializer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/serializer.mjs

@@ -0,0 +1,144 @@
+import "node:module";
+import node_path from "node:path";
+import { ConfigError } from "../utils/errors.mjs";
+import { toPosixPath } from "./helpers.mjs";
+import { recordBundleHash, updateManifest } from "./manifest.mjs";
+import { CountingSet, baseJSBundle, bundleToString } from "../utils/metro-compat.mjs";
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand, manifestPath, manifestOptions) {
+    const bundleHashes = new Map();
+    return async (entryPoint, preModules, graph, options)=>{
+        const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
+        const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        let code;
+        if (true === options.runModule) {
+            const finalPreModules = [
+                getEarlyShared(syncSharedModules),
+                getEarlyRemotes(syncRemoteModules),
+                ...preModules
+            ];
+            code = getBundleCode(entryPoint, finalPreModules, graph, options);
+        } else if (isProjectSource(entryPoint, options.projectRoot)) {
+            const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
+            const finalPreModules = [
+                getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
+                getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
+            ];
+            if (false === options.modulesOnly) finalPreModules.push(...preModules);
+            const finalOptions = {
+                ...options,
+                modulesOnly: false
+            };
+            code = getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        } else code = getBundleCode(entryPoint, preModules, graph, options);
+        if (manifestPath) {
+            recordBundleHash(bundleHashes, code, entryPoint, options.projectRoot, mfConfig);
+            updateManifest(manifestPath, mfConfig, bundleHashes, manifestOptions);
+        }
+        return code;
+    };
+}
+function collectSyncRemoteModules(graph, _remotes) {
+    const remotes = new Set(Object.keys(_remotes));
+    const syncRemoteModules = new Set();
+    for (const [, module] of graph.dependencies)for (const dependency of module.dependencies.values()){
+        if (null !== dependency.data.data.asyncType) continue;
+        const remoteCandidate = dependency.data.name.split('/')[0];
+        const isValidCandidate = remoteCandidate.length < dependency.data.name.length;
+        if (isValidCandidate && remotes.has(remoteCandidate)) syncRemoteModules.add(dependency.data.name);
+    }
+    return Array.from(syncRemoteModules);
+}
+function collectSyncSharedModules(graph, _shared) {
+    const sharedImports = new Set(Object.keys(_shared).map((sharedName)=>_shared[sharedName].import || sharedName));
+    const syncSharedModules = new Set([
+        'react',
+        'react-native'
+    ]);
+    for (const [, module] of graph.dependencies)for (const dependency of module.dependencies.values())if (null === dependency.data.data.asyncType) {
+        if (!module.path.endsWith('init-host.js')) {
+            if (sharedImports.has(dependency.data.name)) syncSharedModules.add(dependency.data.name);
+        }
+    }
+    return Array.from(syncSharedModules);
+}
+function getFederationSharedDependenciesNamespace(scope) {
+    return `globalThis.__FEDERATION__.__NATIVE__["${scope}"].deps.shared`;
+}
+function getFederationRemotesDependenciesNamespace(scope) {
+    return `globalThis.__FEDERATION__.__NATIVE__["${scope}"].deps.remotes`;
+}
+function getSyncShared(shared, entry, scope) {
+    const namespace = getFederationSharedDependenciesNamespace(scope);
+    const code = `${namespace}["${entry}"]=${JSON.stringify(shared)};`;
+    return generateVirtualModule('__required_shared__', code);
+}
+function getSyncRemotes(remotes, entry, scope) {
+    const namespace = getFederationRemotesDependenciesNamespace(scope);
+    const code = `${namespace}["${entry}"]=${JSON.stringify(remotes)};`;
+    return generateVirtualModule('__required_remotes__', code);
+}
+function getEarlyShared(shared) {
+    const code = `var __EARLY_SHARED__=${JSON.stringify(shared)};`;
+    return generateVirtualModule('__early_shared__', code);
+}
+function getEarlyRemotes(remotes) {
+    const code = `var __EARLY_REMOTES__=${JSON.stringify(remotes)};`;
+    return generateVirtualModule('__early_remotes__', code);
+}
+function generateVirtualModule(name, code) {
+    return {
+        dependencies: new Map(),
+        getSource: ()=>Buffer.from(code),
+        inverseDependencies: new CountingSet(),
+        path: name,
+        output: [
+            {
+                type: "js/script/virtual",
+                data: {
+                    code,
+                    lineCount: 1,
+                    map: []
+                }
+            }
+        ]
+    };
+}
+function isProjectSource(entryPoint, projectRoot) {
+    const relativePath = node_path.relative(projectRoot, entryPoint);
+    return !relativePath.startsWith('..') && !relativePath.startsWith('node_modules');
+}
+function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand) {
+    const relativeEntryPath = node_path.relative(projectRoot, entryPoint);
+    const normalizedRelativeEntryPath = normalizeEntryPath(relativeEntryPath);
+    if (!isUsingMFBundleCommand) return removePathExtension(normalizedRelativeEntryPath);
+    const exposeEntries = Object.entries(exposes).map(([exposeKey, exposePath])=>({
+            exposeKey,
+            normalizedExposePath: normalizeEntryPath(exposePath)
+        }));
+    const exactMatch = exposeEntries.find(({ normalizedExposePath })=>normalizedExposePath === normalizedRelativeEntryPath);
+    const extensionlessMatch = exposeEntries.find(({ normalizedExposePath })=>removePathExtension(normalizedExposePath) === removePathExtension(normalizedRelativeEntryPath));
+    const exposedMatchedKey = exactMatch?.exposeKey ?? extensionlessMatch?.exposeKey;
+    if (exposedMatchedKey) {
+        let exposedName = exposedMatchedKey;
+        if (exposedName.startsWith('./')) exposedName = exposedName.slice(2);
+        return `exposed/${exposedName}`;
+    }
+    throw new ConfigError(`Unable to handle entry point: ${relativeEntryPath}. Expected to match an entrypoint with one of the exposed keys, but failed. This is most likely a configuration error. If you believe this is not a configuration issue, please report it as a bug. Debug info: entryPoint="${entryPoint}", projectRoot="${projectRoot}", exposesKeys=[${Object.keys(exposes).join(', ')}]`);
+}
+function normalizeEntryPath(value) {
+    const normalized = toPosixPath(node_path.normalize(value));
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function removePathExtension(value) {
+    const parsed = node_path.posix.parse(value);
+    return node_path.posix.format({
+        dir: parsed.dir,
+        name: parsed.name,
+        ext: ''
+    });
+}
+function getBundleCode(entryPoint, preModules, graph, options) {
+    const { code } = bundleToString(baseJSBundle(entryPoint, preModules, graph, options));
+    return code;
+}
+export { getModuleFederationSerializer };

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

@@ -0,0 +1,2 @@
+import type { ModuleFederationConfig } from '../types';
+export declare function validateOptions(options: ModuleFederationConfig): void;

package/dist/plugin/validate-options.js

@@ -0,0 +1,165 @@
+"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__, {
+    validateOptions: ()=>validateOptions
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_logger_js_namespaceObject = require("../logger.js");
+var external_logger_js_default = /*#__PURE__*/ __webpack_require__.n(external_logger_js_namespaceObject);
+const index_js_namespaceObject = require("../utils/index.js");
+const unsupportedTopLevelOptions = [
+    'library',
+    'remoteType',
+    'runtime',
+    'shareScope',
+    'getPublicPath',
+    'implementation',
+    'manifest',
+    'dev',
+    'virtualRuntimeEntry',
+    'experiments',
+    'bridge',
+    'async',
+    'treeShakingDir',
+    'injectTreeShakingUsedExports',
+    'treeShakingSharedExcludePlugins',
+    'treeShakingSharedPlugins'
+];
+const unsupportedSharedFields = [
+    'packageName',
+    'shareKey',
+    'shareScope',
+    'strictVersion',
+    'treeShaking',
+    'shareStrategy'
+];
+const warningSet = new Set();
+function validateName(name) {
+    if (!name || 'string' != typeof name) throw new index_js_namespaceObject.ConfigError("Option 'name' is required.");
+    const validEcmaIdentifierRegex = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+    if (!validEcmaIdentifierRegex.test(name)) throw new index_js_namespaceObject.ConfigError(`Invalid 'name': ${name}. The 'name' must be a valid JavaScript identifier.`);
+}
+function validateFilename(filename) {
+    if (!filename) return;
+    if (!filename.endsWith('.bundle')) throw new index_js_namespaceObject.ConfigError(`Invalid filename: ${filename}. Filename must end with .bundle extension.`);
+}
+function validateShared(shared) {
+    if (!shared) throw new index_js_namespaceObject.ConfigError('Shared configuration is required.');
+    if ('object' != typeof shared) throw new index_js_namespaceObject.ConfigError('Shared must be an object.');
+    if (Array.isArray(shared)) throw new index_js_namespaceObject.ConfigError('Array format is not supported for shared.');
+    if (!isPlainObject(shared)) throw new index_js_namespaceObject.ConfigError('Shared must be an object.');
+    const sharedObject = shared;
+    if (!('react' in sharedObject)) throw new index_js_namespaceObject.ConfigError("Dependency 'react' must be present in shared.");
+    if (!('react-native' in sharedObject)) throw new index_js_namespaceObject.ConfigError("Dependency 'react-native' must be present in shared.");
+    for (const sharedName of Object.keys(sharedObject)){
+        const sharedConfig = sharedObject[sharedName];
+        if (isRelativePathLike(sharedName)) throw new index_js_namespaceObject.ConfigError('Relative paths are not supported as shared module names.');
+        if (isAbsolutePathLike(sharedName)) throw new index_js_namespaceObject.ConfigError('Absolute paths are not supported as shared module names.');
+        if (sharedName.endsWith('/')) throw new index_js_namespaceObject.ConfigError("Deep import wildcards are not supported as shared module names. You need to list all deep imports explicitly.");
+        if (!isPlainObject(sharedConfig)) throw new index_js_namespaceObject.ConfigError(`Unsupported shared format for '${sharedName}'. Metro only supports object notation for shared modules.`);
+        if ('import' in sharedConfig && false !== sharedConfig.import && 'string' != typeof sharedConfig.import) throw new index_js_namespaceObject.ConfigError(`Unsupported shared.import value for '${sharedName}'. Only string and false are supported in Metro.`);
+        for (const unsupportedField of unsupportedSharedFields)if (unsupportedField in sharedConfig) warnUnsupported(`shared.${sharedName}.${unsupportedField}`, `Option 'shared.${sharedName}.${unsupportedField}' is not supported in Metro and will have no effect.`);
+    }
+}
+function validateRemotes(remotes) {
+    if (void 0 === remotes) return;
+    if (!isPlainObject(remotes)) throw new index_js_namespaceObject.ConfigError('Unsupported remotes format. Metro only supports remotes as Record<string, string>.');
+    for (const remoteConfig of Object.values(remotes))if ('string' != typeof remoteConfig) throw new index_js_namespaceObject.ConfigError('Unsupported remotes format. Metro only supports remotes as Record<string, string>.');
+}
+function validateExposes(exposes) {
+    if (void 0 === exposes) return;
+    if (!isPlainObject(exposes)) throw new index_js_namespaceObject.ConfigError('Unsupported exposes format. Metro only supports exposes as Record<string, string>.');
+    for (const exposeConfig of Object.values(exposes))if ('string' != typeof exposeConfig) throw new index_js_namespaceObject.ConfigError('Unsupported exposes format. Metro only supports exposes as Record<string, string>.');
+}
+function validateRuntimePlugins(runtimePlugins) {
+    if (void 0 === runtimePlugins) return;
+    if (!Array.isArray(runtimePlugins)) throw new index_js_namespaceObject.ConfigError('runtimePlugins must be an array.');
+    runtimePlugins.forEach((runtimePlugin, index)=>{
+        if ('string' == typeof runtimePlugin) return;
+        if (!Array.isArray(runtimePlugin)) throw new index_js_namespaceObject.ConfigError('runtimePlugins entries must be either a string or a tuple of [path, params].');
+        const [pluginPath, pluginParams] = runtimePlugin;
+        if ('string' != typeof pluginPath) throw new index_js_namespaceObject.ConfigError(`Invalid runtimePlugins[${index}] path. Expected a string path.`);
+        if (void 0 !== pluginParams) warnUnsupported(`runtimePlugins[${index}][1]`, `Option 'runtimePlugins[${index}][1]' is not supported in Metro and will have no effect.`);
+    });
+}
+function validateDts(dts) {
+    if (void 0 === dts || 'boolean' == typeof dts) return;
+    if (!isPlainObject(dts)) throw new index_js_namespaceObject.ConfigError("Option 'dts' must be a boolean or a plain object.");
+}
+function validateUnsupportedTopLevelOptions(options) {
+    unsupportedTopLevelOptions.forEach((unsupportedOption)=>{
+        if (void 0 !== options[unsupportedOption]) warnUnsupported(String(unsupportedOption), `Option '${String(unsupportedOption)}' is not supported in Metro and will have no effect.`);
+    });
+}
+function validateDeprecatedOptions(options) {
+    if (options.plugins && options.plugins.length > 0) warnUnsupported('deprecated.plugins', "The 'plugins' option is deprecated. Use 'runtimePlugins' instead. Support for 'plugins' will be removed in the next major version.");
+}
+function warnUnsupported(key, message) {
+    if (warningSet.has(key)) return;
+    warningSet.add(key);
+    external_logger_js_default().warn(message);
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isRelativePathLike(value) {
+    return /^\.{1,2}[\\/]/.test(value);
+}
+function isAbsolutePathLike(value) {
+    return external_node_path_default().posix.isAbsolute(value) || external_node_path_default().win32.isAbsolute(value);
+}
+function validateOptions(options) {
+    validateUnsupportedTopLevelOptions(options);
+    validateDeprecatedOptions(options);
+    validateName(options.name);
+    validateFilename(options.filename);
+    validateRemotes(options.remotes);
+    validateExposes(options.exposes);
+    validateRuntimePlugins(options.runtimePlugins);
+    validateDts(options.dts);
+    validateShared(options.shared);
+}
+exports.validateOptions = __webpack_exports__.validateOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "validateOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/validate-options.mjs

@@ -0,0 +1,117 @@
+import "node:module";
+import node_path from "node:path";
+import logger from "../logger.mjs";
+import { ConfigError } from "../utils/index.mjs";
+const unsupportedTopLevelOptions = [
+    'library',
+    'remoteType',
+    'runtime',
+    'shareScope',
+    'getPublicPath',
+    'implementation',
+    'manifest',
+    'dev',
+    'virtualRuntimeEntry',
+    'experiments',
+    'bridge',
+    'async',
+    'treeShakingDir',
+    'injectTreeShakingUsedExports',
+    'treeShakingSharedExcludePlugins',
+    'treeShakingSharedPlugins'
+];
+const unsupportedSharedFields = [
+    'packageName',
+    'shareKey',
+    'shareScope',
+    'strictVersion',
+    'treeShaking',
+    'shareStrategy'
+];
+const warningSet = new Set();
+function validateName(name) {
+    if (!name || 'string' != typeof name) throw new ConfigError("Option 'name' is required.");
+    const validEcmaIdentifierRegex = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+    if (!validEcmaIdentifierRegex.test(name)) throw new ConfigError(`Invalid 'name': ${name}. The 'name' must be a valid JavaScript identifier.`);
+}
+function validateFilename(filename) {
+    if (!filename) return;
+    if (!filename.endsWith('.bundle')) throw new ConfigError(`Invalid filename: ${filename}. Filename must end with .bundle extension.`);
+}
+function validateShared(shared) {
+    if (!shared) throw new ConfigError('Shared configuration is required.');
+    if ('object' != typeof shared) throw new ConfigError('Shared must be an object.');
+    if (Array.isArray(shared)) throw new ConfigError('Array format is not supported for shared.');
+    if (!isPlainObject(shared)) throw new ConfigError('Shared must be an object.');
+    const sharedObject = shared;
+    if (!('react' in sharedObject)) throw new ConfigError("Dependency 'react' must be present in shared.");
+    if (!('react-native' in sharedObject)) throw new ConfigError("Dependency 'react-native' must be present in shared.");
+    for (const sharedName of Object.keys(sharedObject)){
+        const sharedConfig = sharedObject[sharedName];
+        if (isRelativePathLike(sharedName)) throw new ConfigError('Relative paths are not supported as shared module names.');
+        if (isAbsolutePathLike(sharedName)) throw new ConfigError('Absolute paths are not supported as shared module names.');
+        if (sharedName.endsWith('/')) throw new ConfigError("Deep import wildcards are not supported as shared module names. You need to list all deep imports explicitly.");
+        if (!isPlainObject(sharedConfig)) throw new ConfigError(`Unsupported shared format for '${sharedName}'. Metro only supports object notation for shared modules.`);
+        if ('import' in sharedConfig && false !== sharedConfig.import && 'string' != typeof sharedConfig.import) throw new ConfigError(`Unsupported shared.import value for '${sharedName}'. Only string and false are supported in Metro.`);
+        for (const unsupportedField of unsupportedSharedFields)if (unsupportedField in sharedConfig) warnUnsupported(`shared.${sharedName}.${unsupportedField}`, `Option 'shared.${sharedName}.${unsupportedField}' is not supported in Metro and will have no effect.`);
+    }
+}
+function validateRemotes(remotes) {
+    if (void 0 === remotes) return;
+    if (!isPlainObject(remotes)) throw new ConfigError('Unsupported remotes format. Metro only supports remotes as Record<string, string>.');
+    for (const remoteConfig of Object.values(remotes))if ('string' != typeof remoteConfig) throw new ConfigError('Unsupported remotes format. Metro only supports remotes as Record<string, string>.');
+}
+function validateExposes(exposes) {
+    if (void 0 === exposes) return;
+    if (!isPlainObject(exposes)) throw new ConfigError('Unsupported exposes format. Metro only supports exposes as Record<string, string>.');
+    for (const exposeConfig of Object.values(exposes))if ('string' != typeof exposeConfig) throw new ConfigError('Unsupported exposes format. Metro only supports exposes as Record<string, string>.');
+}
+function validateRuntimePlugins(runtimePlugins) {
+    if (void 0 === runtimePlugins) return;
+    if (!Array.isArray(runtimePlugins)) throw new ConfigError('runtimePlugins must be an array.');
+    runtimePlugins.forEach((runtimePlugin, index)=>{
+        if ('string' == typeof runtimePlugin) return;
+        if (!Array.isArray(runtimePlugin)) throw new ConfigError('runtimePlugins entries must be either a string or a tuple of [path, params].');
+        const [pluginPath, pluginParams] = runtimePlugin;
+        if ('string' != typeof pluginPath) throw new ConfigError(`Invalid runtimePlugins[${index}] path. Expected a string path.`);
+        if (void 0 !== pluginParams) warnUnsupported(`runtimePlugins[${index}][1]`, `Option 'runtimePlugins[${index}][1]' is not supported in Metro and will have no effect.`);
+    });
+}
+function validateDts(dts) {
+    if (void 0 === dts || 'boolean' == typeof dts) return;
+    if (!isPlainObject(dts)) throw new ConfigError("Option 'dts' must be a boolean or a plain object.");
+}
+function validateUnsupportedTopLevelOptions(options) {
+    unsupportedTopLevelOptions.forEach((unsupportedOption)=>{
+        if (void 0 !== options[unsupportedOption]) warnUnsupported(String(unsupportedOption), `Option '${String(unsupportedOption)}' is not supported in Metro and will have no effect.`);
+    });
+}
+function validateDeprecatedOptions(options) {
+    if (options.plugins && options.plugins.length > 0) warnUnsupported('deprecated.plugins', "The 'plugins' option is deprecated. Use 'runtimePlugins' instead. Support for 'plugins' will be removed in the next major version.");
+}
+function warnUnsupported(key, message) {
+    if (warningSet.has(key)) return;
+    warningSet.add(key);
+    logger.warn(message);
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isRelativePathLike(value) {
+    return /^\.{1,2}[\\/]/.test(value);
+}
+function isAbsolutePathLike(value) {
+    return node_path.posix.isAbsolute(value) || node_path.win32.isAbsolute(value);
+}
+function validateOptions(options) {
+    validateUnsupportedTopLevelOptions(options);
+    validateDeprecatedOptions(options);
+    validateName(options.name);
+    validateFilename(options.filename);
+    validateRemotes(options.remotes);
+    validateExposes(options.exposes);
+    validateRuntimePlugins(options.runtimePlugins);
+    validateDts(options.dts);
+    validateShared(options.shared);
+}
+export { validateOptions };

package/dist/runtime/host-entry.js

@@ -0,0 +1,3 @@
+import 'mf:init-host';
+import 'mf:async-require';
+__ENTRYPOINT_IMPORT__;

package/dist/runtime/init-host.js

@@ -0,0 +1,31 @@
+import { loadRemoteToRegistry, loadSharedToRegistry } from 'mf:remote-module-registry';
+import { init } from '@module-federation/runtime';
+__PLUGINS__;
+const usedRemotes = __REMOTES__;
+const usedShared = __SHARED__;
+const name = __NAME__;
+const shareScopeName = 'default';
+const shareStrategy = __SHARE_STRATEGY__;
+const instance = init({
+    name,
+    remotes: usedRemotes,
+    plugins,
+    shared: usedShared,
+    shareStrategy
+});
+globalThis.__FEDERATION__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name] ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name].deps ??= {
+    shared: {},
+    remotes: {}
+};
+globalThis.__FEDERATION__.__NATIVE__[name].init = Promise.all(instance.initializeSharing(shareScopeName, {
+    strategy: shareStrategy,
+    from: 'build',
+    initScope: []
+})).then(()=>Promise.all([
+        ...Object.keys(usedShared).map(loadSharedToRegistry),
+        ...__EARLY_REMOTES__.map(loadRemoteToRegistry)
+    ]));
+__EARLY_SHARED__.forEach(loadSharedToRegistry);