@module-federation/metro 2.0.1 → 2.1.0

package/dist/plugin/validate-options.js

@@ -1,5 +1,14 @@
 "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, {
@@ -26,8 +35,41 @@ __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',
+    'dataPrefetch',
+    '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.`);
 }
@@ -39,17 +81,76 @@ 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 (!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;

package/dist/plugin/validate-options.mjs

@@ -1,7 +1,38 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+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',
+    'dataPrefetch',
+    '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.`);
 }
@@ -13,17 +44,76 @@ 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 (!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/types.d.ts

@@ -1,21 +1,21 @@
-export interface SharedConfig {
-    singleton: boolean;
-    eager: boolean;
-    version: string;
-    requiredVersion: string;
-    import?: false;
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+export interface ModuleFederationConfig extends moduleFederationPlugin.ModuleFederationPluginOptions {
+    /**
+     * @deprecated Use runtimePlugins instead. Scheduled for removal in the next major version.
+     */
+    plugins?: string[];
 }
-export type Shared = Record<string, SharedConfig>;
-export interface ModuleFederationConfig {
+export type ShareObject = Record<string, moduleFederationPlugin.SharedConfig>;
+export interface ModuleFederationConfigNormalized {
     name: string;
-    filename?: string;
-    remotes?: Record<string, string>;
-    exposes?: Record<string, string>;
-    shared?: Shared;
-    shareStrategy?: 'loaded-first' | 'version-first';
-    plugins?: string[];
+    filename: string;
+    remotes: Record<string, string>;
+    exposes: Record<string, string>;
+    shared: ShareObject;
+    shareStrategy: moduleFederationPlugin.SharedStrategy;
+    plugins: string[];
+    dts: boolean | moduleFederationPlugin.PluginDtsOptions;
 }
-export type ModuleFederationConfigNormalized = Required<ModuleFederationConfig>;
 export type ModuleFederationExtraOptions = {
     flags?: MetroMFFlags;
 };

package/dist/utils/federated-remote-types.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+export type FederatedTypesMeta = {
+    zipName: string;
+    apiFileName: string;
+};
+export declare function maybeGenerateFederatedRemoteTypes(opts: {
+    federationConfig: ModuleFederationConfigNormalized;
+    projectRoot: string;
+    outputDir: string;
+    logger: Pick<Console, 'info' | 'warn'>;
+}): Promise<FederatedTypesMeta | undefined>;
+export declare function applyTypesMetaToManifest(manifest: Record<string, any>, typesMeta: FederatedTypesMeta | undefined): Record<string, any>;

package/dist/utils/federated-remote-types.js

@@ -0,0 +1,159 @@
+"use strict";
+var __webpack_modules__ = {
+    "@module-federation/dts-plugin": function(module) {
+        module.exports = import("@module-federation/dts-plugin").then(function(module) {
+            return module;
+        });
+    },
+    "@module-federation/dts-plugin/core": function(module) {
+        module.exports = import("@module-federation/dts-plugin/core").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        maybeGenerateFederatedRemoteTypes: ()=>maybeGenerateFederatedRemoteTypes,
+        applyTypesMetaToManifest: ()=>applyTypesMetaToManifest
+    });
+    const external_node_fs_namespaceObject = require("node:fs");
+    const external_node_util_namespaceObject = require("node:util");
+    var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+    async function maybeGenerateFederatedRemoteTypes(opts) {
+        const { federationConfig, projectRoot, outputDir, logger } = opts;
+        if (false === federationConfig.dts) return;
+        const dtsPlugin = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@module-federation/dts-plugin"));
+        const dtsPluginCore = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@module-federation/dts-plugin/core"));
+        const dtsConfig = true === federationConfig.dts ? {
+            consumeTypes: false
+        } : 'object' != typeof federationConfig.dts || null === federationConfig.dts || Object.prototype.hasOwnProperty.call(federationConfig.dts, 'consumeTypes') ? federationConfig.dts : {
+            ...federationConfig.dts,
+            consumeTypes: false
+        };
+        const mfOptions = {
+            name: federationConfig.name,
+            filename: federationConfig.filename,
+            remotes: federationConfig.remotes,
+            exposes: federationConfig.exposes,
+            shared: federationConfig.shared,
+            dts: dtsConfig
+        };
+        const normalizedDtsOptions = dtsPlugin.normalizeDtsOptions(mfOptions, projectRoot, {
+            defaultGenerateOptions: {
+                generateAPITypes: true,
+                compileInChildProcess: false,
+                abortOnError: false,
+                extractThirdParty: false,
+                extractRemoteTypes: false
+            },
+            defaultConsumeOptions: {
+                abortOnError: true,
+                consumeAPITypes: true
+            }
+        });
+        if (!normalizedDtsOptions) return;
+        const dtsManagerOptions = dtsPlugin.normalizeGenerateTypesOptions({
+            context: projectRoot,
+            outputDir,
+            dtsOptions: normalizedDtsOptions,
+            pluginOptions: mfOptions
+        });
+        if (!dtsManagerOptions) return;
+        if (dtsManagerOptions.host) {
+            let remoteTypeUrls = dtsManagerOptions.host.remoteTypeUrls;
+            if ('function' == typeof remoteTypeUrls) remoteTypeUrls = await remoteTypeUrls();
+            await dtsPluginCore.consumeTypes({
+                ...dtsManagerOptions,
+                host: {
+                    ...dtsManagerOptions.host,
+                    remoteTypeUrls
+                }
+            });
+        }
+        logger.info(`${external_node_util_default().styleText('blue', 'Generating federated types (d.ts)')}`);
+        await dtsPlugin.generateTypesAPI({
+            dtsManagerOptions
+        });
+        const { zipTypesPath, apiTypesPath, zipName, apiFileName } = dtsPluginCore.retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+        const produced = {};
+        const fileExists = async (p)=>{
+            try {
+                await external_node_fs_namespaceObject.promises.stat(p);
+                return true;
+            } catch  {
+                return false;
+            }
+        };
+        if (zipTypesPath && zipName && await fileExists(zipTypesPath)) produced.zipName = zipName;
+        if (apiTypesPath && apiFileName && await fileExists(apiTypesPath)) produced.apiFileName = apiFileName;
+        if (process.env['FEDERATION_DEBUG']) logger.info(`dts debug: zipTypesPath=${zipTypesPath} zipExists=${String(Boolean(produced.zipName))} apiTypesPath=${apiTypesPath} apiExists=${String(Boolean(produced.apiFileName))}`);
+        if (!produced.zipName && !produced.apiFileName) return void logger.warn(`${external_node_util_default().styleText('yellow', 'Federated types enabled, but no types files were produced.')}`);
+        logger.info(`Done writing federated types:\n${external_node_util_default().styleText('dim', [
+            produced.zipName,
+            produced.apiFileName
+        ].filter(Boolean).join('\n'))}`);
+        return {
+            zipName: produced.zipName ?? '',
+            apiFileName: produced.apiFileName ?? ''
+        };
+    }
+    function applyTypesMetaToManifest(manifest, typesMeta) {
+        if (!(null == typesMeta ? void 0 : typesMeta.zipName) && !(null == typesMeta ? void 0 : typesMeta.apiFileName)) return manifest;
+        manifest.metaData = manifest.metaData || {};
+        manifest.metaData.types = manifest.metaData.types || {};
+        if (typesMeta.zipName) manifest.metaData.types.zip = typesMeta.zipName;
+        if (typesMeta.apiFileName) manifest.metaData.types.api = typesMeta.apiFileName;
+        return manifest;
+    }
+})();
+exports.applyTypesMetaToManifest = __webpack_exports__.applyTypesMetaToManifest;
+exports.maybeGenerateFederatedRemoteTypes = __webpack_exports__.maybeGenerateFederatedRemoteTypes;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "applyTypesMetaToManifest",
+    "maybeGenerateFederatedRemoteTypes"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/federated-remote-types.mjs

@@ -0,0 +1,91 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { promises } from "node:fs";
+import node_util from "node:util";
+async function maybeGenerateFederatedRemoteTypes(opts) {
+    const { federationConfig, projectRoot, outputDir, logger } = opts;
+    if (false === federationConfig.dts) return;
+    const dtsPlugin = await import("@module-federation/dts-plugin");
+    const dtsPluginCore = await import("@module-federation/dts-plugin/core");
+    const dtsConfig = true === federationConfig.dts ? {
+        consumeTypes: false
+    } : 'object' != typeof federationConfig.dts || null === federationConfig.dts || Object.prototype.hasOwnProperty.call(federationConfig.dts, 'consumeTypes') ? federationConfig.dts : {
+        ...federationConfig.dts,
+        consumeTypes: false
+    };
+    const mfOptions = {
+        name: federationConfig.name,
+        filename: federationConfig.filename,
+        remotes: federationConfig.remotes,
+        exposes: federationConfig.exposes,
+        shared: federationConfig.shared,
+        dts: dtsConfig
+    };
+    const normalizedDtsOptions = dtsPlugin.normalizeDtsOptions(mfOptions, projectRoot, {
+        defaultGenerateOptions: {
+            generateAPITypes: true,
+            compileInChildProcess: false,
+            abortOnError: false,
+            extractThirdParty: false,
+            extractRemoteTypes: false
+        },
+        defaultConsumeOptions: {
+            abortOnError: true,
+            consumeAPITypes: true
+        }
+    });
+    if (!normalizedDtsOptions) return;
+    const dtsManagerOptions = dtsPlugin.normalizeGenerateTypesOptions({
+        context: projectRoot,
+        outputDir,
+        dtsOptions: normalizedDtsOptions,
+        pluginOptions: mfOptions
+    });
+    if (!dtsManagerOptions) return;
+    if (dtsManagerOptions.host) {
+        let remoteTypeUrls = dtsManagerOptions.host.remoteTypeUrls;
+        if ('function' == typeof remoteTypeUrls) remoteTypeUrls = await remoteTypeUrls();
+        await dtsPluginCore.consumeTypes({
+            ...dtsManagerOptions,
+            host: {
+                ...dtsManagerOptions.host,
+                remoteTypeUrls
+            }
+        });
+    }
+    logger.info(`${node_util.styleText('blue', 'Generating federated types (d.ts)')}`);
+    await dtsPlugin.generateTypesAPI({
+        dtsManagerOptions
+    });
+    const { zipTypesPath, apiTypesPath, zipName, apiFileName } = dtsPluginCore.retrieveTypesAssetsInfo(dtsManagerOptions.remote);
+    const produced = {};
+    const fileExists = async (p)=>{
+        try {
+            await promises.stat(p);
+            return true;
+        } catch  {
+            return false;
+        }
+    };
+    if (zipTypesPath && zipName && await fileExists(zipTypesPath)) produced.zipName = zipName;
+    if (apiTypesPath && apiFileName && await fileExists(apiTypesPath)) produced.apiFileName = apiFileName;
+    if (process.env['FEDERATION_DEBUG']) logger.info(`dts debug: zipTypesPath=${zipTypesPath} zipExists=${String(Boolean(produced.zipName))} apiTypesPath=${apiTypesPath} apiExists=${String(Boolean(produced.apiFileName))}`);
+    if (!produced.zipName && !produced.apiFileName) return void logger.warn(`${node_util.styleText('yellow', 'Federated types enabled, but no types files were produced.')}`);
+    logger.info(`Done writing federated types:\n${node_util.styleText('dim', [
+        produced.zipName,
+        produced.apiFileName
+    ].filter(Boolean).join('\n'))}`);
+    return {
+        zipName: produced.zipName ?? '',
+        apiFileName: produced.apiFileName ?? ''
+    };
+}
+function applyTypesMetaToManifest(manifest, typesMeta) {
+    if (!(null == typesMeta ? void 0 : typesMeta.zipName) && !(null == typesMeta ? void 0 : typesMeta.apiFileName)) return manifest;
+    manifest.metaData = manifest.metaData || {};
+    manifest.metaData.types = manifest.metaData.types || {};
+    if (typesMeta.zipName) manifest.metaData.types.zip = typesMeta.zipName;
+    if (typesMeta.apiFileName) manifest.metaData.types.api = typesMeta.apiFileName;
+    return manifest;
+}
+export { applyTypesMetaToManifest, maybeGenerateFederatedRemoteTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/metro",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Module Federation for Metro bundler",
   "keywords": [
     "module-federation",
@@ -57,8 +57,9 @@
   },
   "dependencies": {
     "@expo/metro-runtime": "^5.0.4",
-    "@module-federation/runtime": "2.0.1",
-    "@module-federation/sdk": "2.0.1"
+    "@module-federation/dts-plugin": "2.1.0",
+    "@module-federation/sdk": "2.1.0",
+    "@module-federation/runtime": "2.1.0"
   },
   "peerDependencies": {
     "@babel/types": "^7.25.0",
@@ -84,6 +85,7 @@
     "@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",
@@ -96,6 +98,8 @@
   },
   "scripts": {
     "build": "rslib build",
+    "test": "vitest run --config vitest.config.mts",
+    "test:watch": "vitest --config vitest.config.mts",
     "typecheck": "tsc --noEmit"
   }
 }

package/dist/babel/transformer.d.ts

@@ -1,2 +0,0 @@
-declare const _exports: any;
-export = _exports;

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

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-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.d.ts

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