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

package/dist/utils/metro-compat.mjs

@@ -0,0 +1,26 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+function resolveAndImport(metro83Path, metro82Path) {
+    let resolvedPath;
+    try {
+        resolvedPath = require.resolve(metro83Path);
+    } catch  {
+        try {
+            resolvedPath = require.resolve(metro82Path);
+        } catch  {
+            throw new Error(`Could not resolve 'metro' module. Tried:\n  - ${metro83Path}\n  - ${metro82Path}\nEnsure 'metro' is installed.`);
+        }
+    }
+    return require(resolvedPath);
+}
+function getDefaultExport(mod) {
+    if (null != mod && 'object' == typeof mod && 'default' in mod) return mod.default;
+    return mod;
+}
+const Server = getDefaultExport(resolveAndImport('metro/private/Server', 'metro/src/Server'));
+const baseJSBundle = getDefaultExport(resolveAndImport('metro/private/DeltaBundler/Serializers/baseJSBundle', 'metro/src/DeltaBundler/Serializers/baseJSBundle'));
+const CountingSet = getDefaultExport(resolveAndImport('metro/private/lib/CountingSet', 'metro/src/lib/CountingSet'));
+const bundleToString = getDefaultExport(resolveAndImport('metro/private/lib/bundleToString', 'metro/src/lib/bundleToString'));
+const relativizeSourceMapModule = resolveAndImport('metro/private/lib/relativizeSourceMap', 'metro/src/lib/relativizeSourceMap');
+const relativizeSourceMapInline = relativizeSourceMapModule.relativizeSourceMapInline || getDefaultExport(relativizeSourceMapModule);
+export { CountingSet, Server, baseJSBundle, bundleToString, relativizeSourceMapInline };

package/dist/utils/vm-manager.d.ts

@@ -0,0 +1,21 @@
+import type { MetroConfig, ServerConfigT, TransformerConfigT } from 'metro-config';
+import type { Server as MetroServer } from './metro-compat';
+type EnhanceMiddleware = ServerConfigT['enhanceMiddleware'];
+type GetTransformOptions = TransformerConfigT['getTransformOptions'];
+type Bundler = ReturnType<ReturnType<MetroServer['getBundler']>['getBundler']>;
+export declare class VirtualModuleManager {
+    private metroConfig;
+    private options;
+    private setupFinished;
+    private virtualModules;
+    constructor(metroConfig: MetroConfig, options?: {
+        forceWriteFileSystem?: boolean;
+    });
+    registerVirtualModule(filePath: string, generator: () => string): void;
+    getMiddleware(): EnhanceMiddleware;
+    getTransformOptions(): GetTransformOptions;
+    setup(bundler: Bundler): void;
+    private ensureFileSystemPatched;
+    private ensureBundlerPatched;
+}
+export {};

package/dist/utils/vm-manager.js

@@ -0,0 +1,118 @@
+"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__, {
+    VirtualModuleManager: ()=>VirtualModuleManager
+});
+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);
+class VirtualModuleManager {
+    registerVirtualModule(filePath, generator) {
+        const moduleCode = generator();
+        if (this.virtualModules.get(filePath) === moduleCode) return;
+        this.virtualModules.set(filePath, moduleCode);
+        if (this.options.forceWriteFileSystem) {
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+                recursive: true
+            });
+            external_node_fs_default().writeFileSync(filePath, moduleCode);
+        }
+    }
+    getMiddleware() {
+        return (middleware, metroServer)=>{
+            const bundler = metroServer.getBundler().getBundler();
+            this.setup(bundler);
+            const originalMiddleware = this.metroConfig.server?.enhanceMiddleware;
+            return originalMiddleware ? originalMiddleware(middleware, metroServer) : middleware;
+        };
+    }
+    getTransformOptions() {
+        return async (...args)=>{
+            if (null === this.setupFinished) throw new Error('Expected virtual module setup to be finished');
+            await this.setupFinished;
+            const originalGetTransformOptions = this.metroConfig.transformer?.getTransformOptions;
+            if (originalGetTransformOptions) return originalGetTransformOptions(...args);
+            return {};
+        };
+    }
+    setup(bundler) {
+        this.setupFinished = (async ()=>{
+            const graph = await bundler.getDependencyGraph();
+            this.ensureFileSystemPatched(graph._fileSystem);
+            this.ensureBundlerPatched(bundler);
+            return true;
+        })();
+    }
+    ensureFileSystemPatched(fs) {
+        if (!fs.getSha1.__vm__patched) {
+            const original_getSha1 = fs.getSha1.bind(fs);
+            fs.getSha1 = (filename)=>{
+                if (this.virtualModules.has(filename)) return `${filename}-${Date.now()}`;
+                return original_getSha1(filename);
+            };
+            fs.getSha1.__vm__patched = true;
+        }
+        return fs;
+    }
+    ensureBundlerPatched(bundler) {
+        if (bundler.transformFile.__vm__patched) return;
+        const transformFile = bundler.transformFile.bind(bundler);
+        bundler.transformFile = async (filePath, transformOptions, fileBuffer)=>{
+            let buffer = fileBuffer;
+            const virtualModule = this.virtualModules.get(filePath);
+            if (virtualModule) buffer = Buffer.from(virtualModule);
+            return transformFile(filePath, transformOptions, buffer);
+        };
+        bundler.transformFile.__vm__patched = true;
+    }
+    constructor(metroConfig, options = {}){
+        this.metroConfig = metroConfig;
+        this.options = options;
+        this.setupFinished = null;
+        this.virtualModules = new Map();
+    }
+}
+exports.VirtualModuleManager = __webpack_exports__.VirtualModuleManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "VirtualModuleManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/vm-manager.mjs

@@ -0,0 +1,70 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+class VirtualModuleManager {
+    registerVirtualModule(filePath, generator) {
+        const moduleCode = generator();
+        if (this.virtualModules.get(filePath) === moduleCode) return;
+        this.virtualModules.set(filePath, moduleCode);
+        if (this.options.forceWriteFileSystem) {
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(filePath, moduleCode);
+        }
+    }
+    getMiddleware() {
+        return (middleware, metroServer)=>{
+            const bundler = metroServer.getBundler().getBundler();
+            this.setup(bundler);
+            const originalMiddleware = this.metroConfig.server?.enhanceMiddleware;
+            return originalMiddleware ? originalMiddleware(middleware, metroServer) : middleware;
+        };
+    }
+    getTransformOptions() {
+        return async (...args)=>{
+            if (null === this.setupFinished) throw new Error('Expected virtual module setup to be finished');
+            await this.setupFinished;
+            const originalGetTransformOptions = this.metroConfig.transformer?.getTransformOptions;
+            if (originalGetTransformOptions) return originalGetTransformOptions(...args);
+            return {};
+        };
+    }
+    setup(bundler) {
+        this.setupFinished = (async ()=>{
+            const graph = await bundler.getDependencyGraph();
+            this.ensureFileSystemPatched(graph._fileSystem);
+            this.ensureBundlerPatched(bundler);
+            return true;
+        })();
+    }
+    ensureFileSystemPatched(fs) {
+        if (!fs.getSha1.__vm__patched) {
+            const original_getSha1 = fs.getSha1.bind(fs);
+            fs.getSha1 = (filename)=>{
+                if (this.virtualModules.has(filename)) return `${filename}-${Date.now()}`;
+                return original_getSha1(filename);
+            };
+            fs.getSha1.__vm__patched = true;
+        }
+        return fs;
+    }
+    ensureBundlerPatched(bundler) {
+        if (bundler.transformFile.__vm__patched) return;
+        const transformFile = bundler.transformFile.bind(bundler);
+        bundler.transformFile = async (filePath, transformOptions, fileBuffer)=>{
+            let buffer = fileBuffer;
+            const virtualModule = this.virtualModules.get(filePath);
+            if (virtualModule) buffer = Buffer.from(virtualModule);
+            return transformFile(filePath, transformOptions, buffer);
+        };
+        bundler.transformFile.__vm__patched = true;
+    }
+    constructor(metroConfig, options = {}){
+        this.metroConfig = metroConfig;
+        this.options = options;
+        this.setupFinished = null;
+        this.virtualModules = new Map();
+    }
+}
+export { VirtualModuleManager };

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@module-federation/metro",
+  "version": "0.0.0-chore-bump-node-22-20260710161714",
+  "description": "Module Federation for Metro bundler",
+  "keywords": [
+    "module-federation",
+    "metro",
+    "react-native"
+  ],
+  "type": "commonjs",
+  "license": "MIT",
+  "contributors": [
+    "Jakub Romańczyk <j.romanczyk@gmail.com> (https://github.com/jbroma)",
+    "Kacper Wiszczuk <kacperwiszczuk@gmail.com> (https://github.com/esemesek)"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/metro-core"
+  },
+  "files": [
+    "dist/",
+    "babel-plugin/",
+    "bootstrap/"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./commands": {
+      "types": "./dist/commands/index.d.ts",
+      "import": "./dist/commands/index.mjs",
+      "require": "./dist/commands/index.js",
+      "default": "./dist/commands/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./babel-plugin": "./babel-plugin/index.js",
+    "./babel-plugin/*": "./babel-plugin/*.js",
+    "./bootstrap": {
+      "default": "./dist/modules/asyncStartup.tsx"
+    }
+  },
+  "dependencies": {
+    "@expo/metro-runtime": "^5.0.4",
+    "@module-federation/dts-plugin": "0.0.0-chore-bump-node-22-20260710161714",
+    "@module-federation/runtime": "0.0.0-chore-bump-node-22-20260710161714",
+    "@module-federation/sdk": "0.0.0-chore-bump-node-22-20260710161714"
+  },
+  "peerDependencies": {
+    "@babel/types": "^7.25.0",
+    "metro": "^0.82.1",
+    "metro-config": "^0.82.1",
+    "metro-file-map": "^0.82.1",
+    "metro-resolver": "^0.82.1",
+    "metro-source-map": "^0.82.1",
+    "react": ">=19.0.0",
+    "react-native": ">=0.79.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.23.2",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
+    "@types/node": "^20.19.5",
+    "@types/react": "^19.1.0",
+    "memfs": "4.46.0",
+    "metro": "^0.82.1",
+    "metro-config": "^0.82.1",
+    "metro-file-map": "^0.82.1",
+    "metro-resolver": "^0.82.1",
+    "metro-source-map": "^0.82.1",
+    "react": "19.1.0",
+    "react-native": "0.80.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "test": "rstest",
+    "test:watch": "rstest --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.{ts,tsx,js,jsx}\""
+  }
+}