@module-federation/metro 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/dist/plugin/serializer.js

@@ -0,0 +1,171 @@
+"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__, {
+    getModuleFederationSerializer: ()=>getModuleFederationSerializer
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const baseJSBundle_namespaceObject = require("metro/src/DeltaBundler/Serializers/baseJSBundle");
+var baseJSBundle_default = /*#__PURE__*/ __webpack_require__.n(baseJSBundle_namespaceObject);
+const CountingSet_namespaceObject = require("metro/src/lib/CountingSet");
+var CountingSet_default = /*#__PURE__*/ __webpack_require__.n(CountingSet_namespaceObject);
+const bundleToString_namespaceObject = require("metro/src/lib/bundleToString");
+var bundleToString_default = /*#__PURE__*/ __webpack_require__.n(bundleToString_namespaceObject);
+const errors_js_namespaceObject = require("../utils/errors.js");
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
+    return async (entryPoint, preModules, graph, options)=>{
+        const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
+        const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        if (true === options.runModule) {
+            const finalPreModules = [
+                getEarlyShared(syncSharedModules),
+                getEarlyRemotes(syncRemoteModules),
+                ...preModules
+            ];
+            return getBundleCode(entryPoint, finalPreModules, graph, options);
+        }
+        if (!isProjectSource(entryPoint, options.projectRoot)) return getBundleCode(entryPoint, preModules, graph, options);
+        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
+        };
+        return getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+    };
+}
+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_default())(),
+        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);
+    if (!isUsingMFBundleCommand) {
+        const { dir, name } = external_node_path_default().parse(relativeEntryPath);
+        return external_node_path_default().format({
+            dir,
+            name,
+            ext: ''
+        });
+    }
+    const exposedMatchedKey = Object.keys(exposes).find((exposeKey)=>exposes[exposeKey].match(relativeEntryPath));
+    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 getBundleCode(entryPoint, preModules, graph, options) {
+    const { code } = bundleToString_default()(baseJSBundle_default()(entryPoint, preModules, graph, options));
+    return code;
+}
+exports.getModuleFederationSerializer = __webpack_exports__.getModuleFederationSerializer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getModuleFederationSerializer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/serializer.mjs

@@ -0,0 +1,151 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_path from "node:path";
+import { ConfigError } from "../utils/errors.mjs";
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+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 = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+const baseJSBundle_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/DeltaBundler/Serializers/baseJSBundle");
+var baseJSBundle_default = /*#__PURE__*/ __webpack_require__.n(baseJSBundle_namespaceObject);
+const CountingSet_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/lib/CountingSet");
+var CountingSet_default = /*#__PURE__*/ __webpack_require__.n(CountingSet_namespaceObject);
+const bundleToString_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/lib/bundleToString");
+var bundleToString_default = /*#__PURE__*/ __webpack_require__.n(bundleToString_namespaceObject);
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
+    return async (entryPoint, preModules, graph, options)=>{
+        const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
+        const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        if (true === options.runModule) {
+            const finalPreModules = [
+                getEarlyShared(syncSharedModules),
+                getEarlyRemotes(syncRemoteModules),
+                ...preModules
+            ];
+            return getBundleCode(entryPoint, finalPreModules, graph, options);
+        }
+        if (!isProjectSource(entryPoint, options.projectRoot)) return getBundleCode(entryPoint, preModules, graph, options);
+        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
+        };
+        return getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+    };
+}
+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_default())(),
+        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);
+    if (!isUsingMFBundleCommand) {
+        const { dir, name } = node_path.parse(relativeEntryPath);
+        return node_path.format({
+            dir,
+            name,
+            ext: ''
+        });
+    }
+    const exposedMatchedKey = Object.keys(exposes).find((exposeKey)=>exposes[exposeKey].match(relativeEntryPath));
+    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 getBundleCode(entryPoint, preModules, graph, options) {
+    const { code } = bundleToString_default()(baseJSBundle_default()(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,61 @@
+"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__, {
+    validateOptions: ()=>validateOptions
+});
+const index_js_namespaceObject = require("../utils/index.js");
+function validateName(name) {
+    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 (!('react' in shared)) throw new index_js_namespaceObject.ConfigError("Dependency 'react' must be present in shared.");
+    if (!('react-native' in shared)) throw new index_js_namespaceObject.ConfigError("Dependency 'react-native' must be present in shared.");
+    for (const sharedName of Object.keys(shared)){
+        if (sharedName.startsWith('./') || sharedName.startsWith('../')) throw new index_js_namespaceObject.ConfigError('Relative paths are not supported as shared module names.');
+        if (sharedName.startsWith('/')) 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.");
+    }
+}
+function validateOptions(options) {
+    validateName(options.name);
+    validateFilename(options.filename);
+    validateShared(options.shared);
+}
+exports.validateOptions = __webpack_exports__.validateOptions;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "validateOptions"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/validate-options.mjs

@@ -0,0 +1,29 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { ConfigError } from "../utils/index.mjs";
+function validateName(name) {
+    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 (!('react' in shared)) throw new ConfigError("Dependency 'react' must be present in shared.");
+    if (!('react-native' in shared)) throw new ConfigError("Dependency 'react-native' must be present in shared.");
+    for (const sharedName of Object.keys(shared)){
+        if (sharedName.startsWith('./') || sharedName.startsWith('../')) throw new ConfigError('Relative paths are not supported as shared module names.');
+        if (sharedName.startsWith('/')) 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.");
+    }
+}
+function validateOptions(options) {
+    validateName(options.name);
+    validateFilename(options.filename);
+    validateShared(options.shared);
+}
+export { validateOptions };

package/dist/runtime/host-entry.d.ts

@@ -0,0 +1 @@
+export {};

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.d.ts

@@ -0,0 +1 @@
+export {};

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);

package/dist/runtime/remote-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/remote-entry.js

@@ -0,0 +1,57 @@
+import 'mf:async-require';
+import { loadSharedToRegistry } from 'mf:remote-module-registry';
+import { init as runtimeInit } from '@module-federation/runtime';
+__PLUGINS__;
+const usedRemotes = __REMOTES__;
+const usedShared = __SHARED__;
+const exposesMap = __EXPOSES_MAP__;
+function get(moduleName) {
+    if (!(moduleName in exposesMap)) throw new Error(`Module ${moduleName} does not exist in container.`);
+    return exposesMap[moduleName]().then((m)=>()=>m);
+}
+const initTokens = {};
+const name = __NAME__;
+const shareScopeName = 'default';
+const shareStrategy = __SHARE_STRATEGY__;
+let hmrInitialized = false;
+async function init(shared = {}, initScope = []) {
+    const instance = runtimeInit({
+        name,
+        remotes: usedRemotes,
+        shared: usedShared,
+        plugins,
+        shareStrategy
+    });
+    let initToken = initTokens[shareScopeName];
+    if (!initToken) initToken = initTokens[shareScopeName] = {
+        from: name
+    };
+    if (initScope.indexOf(initToken) >= 0) return;
+    initScope.push(initToken);
+    instance.initShareScopeMap(shareScopeName, shared);
+    const initSharingPromise = Promise.all(instance.initializeSharing(shareScopeName, {
+        strategy: shareStrategy,
+        from: 'build',
+        initScope
+    }));
+    __EARLY_SHARED__.forEach(loadSharedToRegistry);
+    await initSharingPromise;
+    if (__DEV__ && !hmrInitialized) {
+        const hmr = require('mf:remote-hmr');
+        hmr.setup();
+        hmrInitialized = true;
+    }
+    await Promise.all(Object.keys(shared).map(loadSharedToRegistry));
+    return instance;
+}
+globalThis.__FEDERATION__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__ ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name] ??= {};
+globalThis.__FEDERATION__.__NATIVE__[name].deps ??= {
+    shared: {},
+    remotes: {}
+};
+globalThis.__FEDERATION__.__NATIVE__[name].exports = {
+    get,
+    init
+};

package/dist/runtime/remote-hmr.d.ts

@@ -0,0 +1 @@
+export function setup(): void;

package/dist/runtime/remote-hmr.js

@@ -0,0 +1,19 @@
+function parseUrl(url) {
+    const urlPattern = /^((https?):\/\/([^:/]+)(?::(\d+))?)\/?(.*)?$/;
+    const match = url.match(urlPattern);
+    if (!match) throw new Error('Invalid URL: ' + url);
+    const [, origin, scheme, host, port, path] = match;
+    return {
+        origin,
+        scheme,
+        host,
+        port,
+        path
+    };
+}
+export function setup() {
+    const HMRClient = require('react-native/Libraries/Utilities/HMRClient');
+    const platform = require('react-native').Platform.OS;
+    const { scheme, host, port, path } = parseUrl(globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].origin);
+    HMRClient.default.setup(platform, path, host, port, true, scheme);
+}

package/dist/runtime/remote-module-registry.d.ts

@@ -0,0 +1,7 @@
+export function loadAndGetShared(id: any): Promise<any>;
+export function loadAndGetRemote(id: any): Promise<any>;
+export function loadRemoteToRegistry(id: any): Promise<void>;
+export function loadSharedToRegistry(id: any): void | Promise<void>;
+export function loadSharedToRegistryAsync(id: any): Promise<void>;
+export function loadSharedToRegistrySync(id: any): void;
+export function getModuleFromRegistry(id: any): any;

package/dist/runtime/remote-module-registry.js

@@ -0,0 +1,57 @@
+import { loadRemote, loadShare, loadShareSync } from '@module-federation/runtime';
+const registry = {};
+const loading = {};
+const earlyModuleTest = __EARLY_MODULE_TEST__;
+function cloneModule(module, target) {
+    for (const key of Object.getOwnPropertyNames(module)){
+        const descriptor = Object.getOwnPropertyDescriptor(module, key);
+        Object.defineProperty(target, key, descriptor);
+    }
+}
+export async function loadAndGetShared(id) {
+    await loadSharedToRegistry(id);
+    return getModuleFromRegistry(id);
+}
+export async function loadAndGetRemote(id) {
+    await loadRemoteToRegistry(id);
+    return getModuleFromRegistry(id);
+}
+export async function loadRemoteToRegistry(id) {
+    const promise = loading[id];
+    if (promise) await promise;
+    else {
+        registry[id] = {};
+        loading[id] = (async ()=>{
+            const remoteModule = await loadRemote(id);
+            cloneModule(remoteModule, registry[id]);
+        })();
+        await loading[id];
+    }
+}
+export function loadSharedToRegistry(id) {
+    if (earlyModuleTest.test(id)) return loadSharedToRegistrySync(id);
+    return loadSharedToRegistryAsync(id);
+}
+export async function loadSharedToRegistryAsync(id) {
+    const promise = loading[id];
+    if (promise) await promise;
+    else {
+        registry[id] = {};
+        loading[id] = (async ()=>{
+            const factory = await loadShare(id);
+            const sharedModule = factory();
+            cloneModule(sharedModule, registry[id]);
+        })();
+        await loading[id];
+    }
+}
+export function loadSharedToRegistrySync(id) {
+    if (loading[id]) return;
+    loading[id] = loadShareSync(id);
+    registry[id] = loading[id]();
+}
+export function getModuleFromRegistry(id) {
+    const module = registry[id];
+    if (!module) throw new Error(`Module ${id} not found in registry`);
+    return module;
+}

package/dist/runtime/remote-module.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/remote-module.js

@@ -0,0 +1,2 @@
+import { getModuleFromRegistry } from 'mf:remote-module-registry';
+module.exports = getModuleFromRegistry(__MODULE_ID__);

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface SharedConfig {
+    singleton: boolean;
+    eager: boolean;
+    version: string;
+    requiredVersion: string;
+    import?: false;
+}
+export type Shared = Record<string, SharedConfig>;
+export interface ModuleFederationConfig {
+    name: string;
+    filename?: string;
+    remotes?: Record<string, string>;
+    exposes?: Record<string, string>;
+    shared?: Shared;
+    shareStrategy?: 'loaded-first' | 'version-first';
+    plugins?: string[];
+}
+export type ModuleFederationConfigNormalized = Required<ModuleFederationConfig>;
+export type ModuleFederationExtraOptions = {
+    flags?: MetroMFFlags;
+};
+export type MetroMFFlags = {
+    unstable_patchHMRClient?: boolean;
+    unstable_patchInitializeCore?: boolean;
+    unstable_patchRuntimeRequire?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types.mjs

@@ -0,0 +1,2 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;