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

package/dist/plugin/manifest.mjs

@@ -0,0 +1,185 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { MANIFEST_FILENAME, TMP_DIR_NAME } from "./constants.mjs";
+import { removeExtension, toPosixPath } from "./helpers.mjs";
+function createManifest(options, mfMetroPath, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifestPath = node_path.join(mfMetroPath, MANIFEST_FILENAME);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+function updateManifest(manifestPath, options, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    const existingManifest = readManifest(manifestPath);
+    if (existingManifest?.metaData?.types) manifest.metaData.types = {
+        ...manifest.metaData.types,
+        ...existingManifest.metaData.types
+    };
+    node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
+    return manifestPath;
+}
+function recordBundleHash(hashes, code, entryPoint, projectRoot, config) {
+    const hash = node_crypto.createHash('sha256').update(code).digest('hex');
+    const key = resolveBundleKey(entryPoint, projectRoot, config);
+    if (key) hashes.set(key, hash);
+}
+function generateManifest(config, hashes, manifestOptions = {}) {
+    return {
+        id: config.name,
+        name: config.name,
+        metaData: generateMetaData(config, hashes),
+        exposes: generateExposes(config, hashes),
+        remotes: generateRemotes(config),
+        shared: generateShared(config, hashes, manifestOptions)
+    };
+}
+function generateMetaData(config, hashes) {
+    return {
+        name: config.name,
+        type: 'app',
+        buildInfo: {
+            buildVersion: '1.0.0',
+            buildName: config.name,
+            hash: hashes?.get(`container:${config.name}`) ?? ''
+        },
+        remoteEntry: {
+            name: config.filename,
+            path: '',
+            type: 'global'
+        },
+        types: {
+            path: '',
+            name: '',
+            api: '',
+            zip: ''
+        },
+        globalName: config.name,
+        pluginVersion: '',
+        publicPath: 'auto'
+    };
+}
+function generateExposes(config, hashes) {
+    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,
+            hash: hashes?.get(`expose:${formatKey}`) ?? ''
+        };
+    });
+}
+function generateRemotes(config) {
+    return Object.keys(config.remotes).map((remote)=>({
+            federationContainerName: config.remotes[remote],
+            moduleName: remote,
+            alias: remote,
+            entry: '*'
+        }));
+}
+function generateShared(config, hashes, manifestOptions = {}) {
+    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(getSharedAssetPath(sharedName, manifestOptions));
+        return {
+            id: sharedName,
+            name: sharedName,
+            version: getManifestVersion(config.shared[sharedName].version),
+            requiredVersion: getManifestRequiredVersion(config.shared[sharedName].requiredVersion),
+            singleton: config.shared[sharedName].singleton,
+            hash: hashes?.get(`shared:${sharedName}`) ?? '',
+            assets
+        };
+    });
+}
+function resolveBundleKey(entryPoint, projectRoot, config) {
+    const relPath = toPosixPath(node_path.relative(projectRoot, entryPoint));
+    const normalizedRel = relPath.startsWith('./') ? relPath.slice(2) : relPath;
+    const normalizedRelNoExt = removeExtension(normalizedRel);
+    for (const [exposeKey, exposePath] of Object.entries(config.exposes)){
+        const normalizedExpose = toPosixPath(exposePath.startsWith('./') ? exposePath.slice(2) : exposePath);
+        if (normalizedRel === normalizedExpose || normalizedRelNoExt === removeExtension(normalizedExpose)) return `expose:${exposeKey.replace('./', '')}`;
+    }
+    if (removeExtension(node_path.basename(entryPoint)) === removeExtension(node_path.basename(config.filename))) return `container:${config.name}`;
+    const virtualSharedKey = resolveDevVirtualSharedKey(entryPoint, projectRoot, config);
+    if (virtualSharedKey) return virtualSharedKey;
+    const absPath = toPosixPath(node_path.resolve(entryPoint));
+    const nmMatch = absPath.match(/.*node_modules\/(.+)/);
+    if (nmMatch) {
+        const modulePath = removeExtension(nmMatch[1]);
+        const sharedKey = findSharedKeyForModulePath(modulePath, config);
+        if (sharedKey) return `shared:${sharedKey}`;
+    }
+    return null;
+}
+function normalizeManifestArgs(hashesOrOptions, manifestOptions) {
+    if (hashesOrOptions instanceof Map) return {
+        hashes: hashesOrOptions,
+        options: manifestOptions ?? {}
+    };
+    return {
+        hashes: void 0,
+        options: hashesOrOptions ?? {}
+    };
+}
+function readManifest(manifestPath) {
+    if (!node_fs.existsSync(manifestPath)) return;
+    return JSON.parse(node_fs.readFileSync(manifestPath, 'utf-8'));
+}
+function getSharedVirtualModuleName(sharedName) {
+    return sharedName.replaceAll('/', '_');
+}
+function getSharedVirtualModulePath(tmpDirPath, sharedName) {
+    return node_path.join(tmpDirPath, 'shared', `${getSharedVirtualModuleName(sharedName)}.js`);
+}
+function getSharedAssetPath(sharedName, manifestOptions) {
+    if ('development' === manifestOptions.target && manifestOptions.projectRoot && manifestOptions.tmpDirPath) return toPosixPath(node_path.relative(manifestOptions.projectRoot, getSharedVirtualModulePath(manifestOptions.tmpDirPath, sharedName)));
+    return `shared/${sharedName}.bundle`;
+}
+function resolveDevVirtualSharedKey(entryPoint, projectRoot, config) {
+    const relativePath = toPosixPath(node_path.relative(projectRoot, entryPoint));
+    const virtualSharedPrefix = `node_modules/${TMP_DIR_NAME}/shared/`;
+    if (!relativePath.startsWith(virtualSharedPrefix)) return null;
+    const virtualModuleName = removeExtension(relativePath.slice(virtualSharedPrefix.length));
+    const sharedKey = Object.keys(config.shared).find((sharedName)=>getSharedVirtualModuleName(sharedName) === virtualModuleName);
+    return sharedKey ? `shared:${sharedKey}` : null;
+}
+function findSharedKeyForModulePath(modulePath, config) {
+    const sharedEntries = Object.entries(config.shared).map(([sharedName, sharedConfig])=>{
+        const importName = 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+        return {
+            importName,
+            sharedName
+        };
+    }).sort((a, b)=>b.importName.length - a.importName.length);
+    const normalizedModulePath = toPosixPath(modulePath);
+    for (const { importName, sharedName } of sharedEntries)if (normalizedModulePath === importName || normalizedModulePath.startsWith(`${importName}/`)) return sharedName;
+    return null;
+}
+function getManifestVersion(version) {
+    return 'string' == typeof version ? version : '';
+}
+function getManifestRequiredVersion(requiredVersion) {
+    return 'string' == typeof requiredVersion ? requiredVersion : '*';
+}
+function getEmptyAssets() {
+    return {
+        js: {
+            sync: [],
+            async: []
+        },
+        css: {
+            sync: [],
+            async: []
+        }
+    };
+}
+export { createManifest, getSharedVirtualModuleName, getSharedVirtualModulePath, recordBundleHash, 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,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+function normalizeExtraOptions(extraOptions) {
+    return {
+        ...extraOptions,
+        flags: {
+            unstable_patchHMRClient: false,
+            unstable_patchInitializeCore: false,
+            unstable_patchRuntimeRequire: false,
+            ...extraOptions?.flags
+        }
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    normalizeExtraOptions: ()=>normalizeExtraOptions
+});
+exports.normalizeExtraOptions = __webpack_exports__.normalizeExtraOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeExtraOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,13 @@
+import "node:module";
+function normalizeExtraOptions(extraOptions) {
+    return {
+        ...extraOptions,
+        flags: {
+            unstable_patchHMRClient: false,
+            unstable_patchInitializeCore: false,
+            unstable_patchRuntimeRequire: false,
+            ...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 {};

package/dist/plugin/normalize-options.js

@@ -0,0 +1,139 @@
+"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__, {
+    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");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+function normalizeOptions(options, { projectRoot, tmpDirPath }) {
+    const shared = getNormalizedShared(options, projectRoot);
+    const remotes = getNormalizedRemotes(options);
+    const exposes = getNormalizedExposes(options);
+    const shareStrategy = getNormalizedShareStrategy(options);
+    const plugins = getNormalizedPlugins(options, tmpDirPath, projectRoot);
+    return {
+        name: options.name,
+        filename: options.filename ?? external_constants_js_namespaceObject.DEFAULT_ENTRY_FILENAME,
+        remotes,
+        exposes,
+        shared,
+        shareStrategy,
+        plugins,
+        dts: options.dts ?? false
+    };
+}
+function getNormalizedRemotes(options) {
+    return {
+        ...options.remotes ?? {}
+    };
+}
+function getNormalizedExposes(options) {
+    return {
+        ...options.exposes ?? {}
+    };
+}
+function getNormalizedShared(options, projectRoot) {
+    const pkg = getProjectPackageJson(projectRoot);
+    const sharedInput = options.shared ?? {};
+    const shared = Object.entries(sharedInput).reduce((acc, [sharedName, config])=>{
+        if ('string' == typeof config) return acc;
+        const metroSharedConfig = {
+            ...config
+        };
+        acc[sharedName] = metroSharedConfig;
+        return acc;
+    }, {});
+    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) shared[sharedName].requiredVersion = pkg.dependencies?.[sharedName] || 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, projectRoot) {
+    const runtimePlugins = getNormalizedRuntimePlugins(options);
+    const plugins = options.plugins ?? [];
+    const allPlugins = [
+        require.resolve('../modules/metroCorePlugin.ts'),
+        ...runtimePlugins,
+        ...plugins
+    ];
+    const deduplicatedPlugins = Array.from(new Set(allPlugins));
+    return deduplicatedPlugins.map((pluginPath)=>{
+        if (!isLocalPluginPath(pluginPath, projectRoot)) return pluginPath;
+        const resolvedPluginPath = external_node_path_default().isAbsolute(pluginPath) ? pluginPath : external_node_path_default().resolve(projectRoot, pluginPath);
+        return (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(tmpDirPath, resolvedPluginPath));
+    });
+}
+function isLocalPluginPath(pluginPath, projectRoot) {
+    if (external_node_path_default().isAbsolute(pluginPath)) return true;
+    if (pluginPath.startsWith('./') || pluginPath.startsWith('../')) return true;
+    return external_node_fs_default().existsSync(external_node_path_default().resolve(projectRoot, pluginPath));
+}
+function getNormalizedRuntimePlugins(options) {
+    const runtimePlugins = options.runtimePlugins ?? [];
+    const normalizedRuntimePlugins = [];
+    runtimePlugins.forEach((runtimePlugin)=>{
+        if ('string' == typeof runtimePlugin) return void normalizedRuntimePlugins.push(runtimePlugin);
+        if (Array.isArray(runtimePlugin)) {
+            const [pluginPath] = runtimePlugin;
+            if ('string' == typeof pluginPath) normalizedRuntimePlugins.push(pluginPath);
+        }
+    });
+    return normalizedRuntimePlugins;
+}
+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 __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/normalize-options.mjs

@@ -0,0 +1,92 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { DEFAULT_ENTRY_FILENAME } from "./constants.mjs";
+import { toPosixPath } from "./helpers.mjs";
+function normalizeOptions(options, { projectRoot, tmpDirPath }) {
+    const shared = getNormalizedShared(options, projectRoot);
+    const remotes = getNormalizedRemotes(options);
+    const exposes = getNormalizedExposes(options);
+    const shareStrategy = getNormalizedShareStrategy(options);
+    const plugins = getNormalizedPlugins(options, tmpDirPath, projectRoot);
+    return {
+        name: options.name,
+        filename: options.filename ?? DEFAULT_ENTRY_FILENAME,
+        remotes,
+        exposes,
+        shared,
+        shareStrategy,
+        plugins,
+        dts: options.dts ?? false
+    };
+}
+function getNormalizedRemotes(options) {
+    return {
+        ...options.remotes ?? {}
+    };
+}
+function getNormalizedExposes(options) {
+    return {
+        ...options.exposes ?? {}
+    };
+}
+function getNormalizedShared(options, projectRoot) {
+    const pkg = getProjectPackageJson(projectRoot);
+    const sharedInput = options.shared ?? {};
+    const shared = Object.entries(sharedInput).reduce((acc, [sharedName, config])=>{
+        if ('string' == typeof config) return acc;
+        const metroSharedConfig = {
+            ...config
+        };
+        acc[sharedName] = metroSharedConfig;
+        return acc;
+    }, {});
+    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) shared[sharedName].requiredVersion = pkg.dependencies?.[sharedName] || 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, projectRoot) {
+    const runtimePlugins = getNormalizedRuntimePlugins(options);
+    const plugins = options.plugins ?? [];
+    const allPlugins = [
+        require.resolve('../modules/metroCorePlugin.ts'),
+        ...runtimePlugins,
+        ...plugins
+    ];
+    const deduplicatedPlugins = Array.from(new Set(allPlugins));
+    return deduplicatedPlugins.map((pluginPath)=>{
+        if (!isLocalPluginPath(pluginPath, projectRoot)) return pluginPath;
+        const resolvedPluginPath = node_path.isAbsolute(pluginPath) ? pluginPath : node_path.resolve(projectRoot, pluginPath);
+        return toPosixPath(node_path.relative(tmpDirPath, resolvedPluginPath));
+    });
+}
+function isLocalPluginPath(pluginPath, projectRoot) {
+    if (node_path.isAbsolute(pluginPath)) return true;
+    if (pluginPath.startsWith('./') || pluginPath.startsWith('../')) return true;
+    return node_fs.existsSync(node_path.resolve(projectRoot, pluginPath));
+}
+function getNormalizedRuntimePlugins(options) {
+    const runtimePlugins = options.runtimePlugins ?? [];
+    const normalizedRuntimePlugins = [];
+    runtimePlugins.forEach((runtimePlugin)=>{
+        if ('string' == typeof runtimePlugin) return void normalizedRuntimePlugins.push(runtimePlugin);
+        if (Array.isArray(runtimePlugin)) {
+            const [pluginPath] = runtimePlugin;
+            if ('string' == typeof pluginPath) normalizedRuntimePlugins.push(pluginPath);
+        }
+    });
+    return normalizedRuntimePlugins;
+}
+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,26 @@
+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: Pick<VirtualModuleManager, 'registerVirtualModule'>;
+    customResolver?: CustomResolver;
+}
+export declare function createResolveRequest({ vmManager, options, hacks, paths, isRemote, customResolver, }: CreateResolveRequestOptions): CustomResolver;
+export {};