@module-federation/metro 2.0.0 → 2.1.0

package/dist/plugin/serializer.js

@@ -37,13 +37,9 @@ __webpack_require__.d(__webpack_exports__, {
 });
 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");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+const metro_compat_js_namespaceObject = require("../utils/metro-compat.js");
 function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
     return async (entryPoint, preModules, graph, options)=>{
         const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
@@ -122,7 +118,7 @@ function generateVirtualModule(name, code) {
     return {
         dependencies: new Map(),
         getSource: ()=>Buffer.from(code),
-        inverseDependencies: new (CountingSet_default())(),
+        inverseDependencies: new metro_compat_js_namespaceObject.CountingSet(),
         path: name,
         output: [
             {
@@ -142,6 +138,7 @@ function isProjectSource(entryPoint, projectRoot) {
 }
 function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand) {
     const relativeEntryPath = external_node_path_default().relative(projectRoot, entryPoint);
+    const normalizedRelativeEntryPath = normalizeEntryPath(relativeEntryPath);
     if (!isUsingMFBundleCommand) {
         const { dir, name } = external_node_path_default().parse(relativeEntryPath);
         return external_node_path_default().format({
@@ -150,7 +147,13 @@ function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand)
             ext: ''
         });
     }
-    const exposedMatchedKey = Object.keys(exposes).find((exposeKey)=>exposes[exposeKey].match(relativeEntryPath));
+    const exposeEntries = Object.entries(exposes).map(([exposeKey, exposePath])=>({
+            exposeKey,
+            normalizedExposePath: normalizeEntryPath(exposePath)
+        }));
+    const exactMatch = exposeEntries.find(({ normalizedExposePath })=>normalizedExposePath === normalizedRelativeEntryPath);
+    const extensionlessMatch = exposeEntries.find(({ normalizedExposePath })=>removePathExtension(normalizedExposePath) === removePathExtension(normalizedRelativeEntryPath));
+    const exposedMatchedKey = (null == exactMatch ? void 0 : exactMatch.exposeKey) ?? (null == extensionlessMatch ? void 0 : extensionlessMatch.exposeKey);
     if (exposedMatchedKey) {
         let exposedName = exposedMatchedKey;
         if (exposedName.startsWith('./')) exposedName = exposedName.slice(2);
@@ -158,8 +161,20 @@ function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand)
     }
     throw new errors_js_namespaceObject.ConfigError(`Unable to handle entry point: ${relativeEntryPath}. Expected to match an entrypoint with one of the exposed keys, but failed. This is most likely a configuration error. If you believe this is not a configuration issue, please report it as a bug. Debug info: entryPoint="${entryPoint}", projectRoot="${projectRoot}", exposesKeys=[${Object.keys(exposes).join(', ')}]`);
 }
+function normalizeEntryPath(value) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(value));
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function removePathExtension(value) {
+    const parsed = external_node_path_default().posix.parse(value);
+    return external_node_path_default().posix.format({
+        dir: parsed.dir,
+        name: parsed.name,
+        ext: ''
+    });
+}
 function getBundleCode(entryPoint, preModules, graph, options) {
-    const { code } = bundleToString_default()(baseJSBundle_default()(entryPoint, preModules, graph, options));
+    const { code } = (0, metro_compat_js_namespaceObject.bundleToString)((0, metro_compat_js_namespaceObject.baseJSBundle)(entryPoint, preModules, graph, options));
     return code;
 }
 exports.getModuleFederationSerializer = __webpack_exports__.getModuleFederationSerializer;

package/dist/plugin/serializer.mjs

@@ -2,34 +2,8 @@ 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);
+import { toPosixPath } from "./helpers.mjs";
+import { CountingSet, baseJSBundle, bundleToString } from "../utils/metro-compat.mjs";
 function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
     return async (entryPoint, preModules, graph, options)=>{
         const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
@@ -108,7 +82,7 @@ function generateVirtualModule(name, code) {
     return {
         dependencies: new Map(),
         getSource: ()=>Buffer.from(code),
-        inverseDependencies: new (CountingSet_default())(),
+        inverseDependencies: new CountingSet(),
         path: name,
         output: [
             {
@@ -128,6 +102,7 @@ function isProjectSource(entryPoint, projectRoot) {
 }
 function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand) {
     const relativeEntryPath = node_path.relative(projectRoot, entryPoint);
+    const normalizedRelativeEntryPath = normalizeEntryPath(relativeEntryPath);
     if (!isUsingMFBundleCommand) {
         const { dir, name } = node_path.parse(relativeEntryPath);
         return node_path.format({
@@ -136,7 +111,13 @@ function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand)
             ext: ''
         });
     }
-    const exposedMatchedKey = Object.keys(exposes).find((exposeKey)=>exposes[exposeKey].match(relativeEntryPath));
+    const exposeEntries = Object.entries(exposes).map(([exposeKey, exposePath])=>({
+            exposeKey,
+            normalizedExposePath: normalizeEntryPath(exposePath)
+        }));
+    const exactMatch = exposeEntries.find(({ normalizedExposePath })=>normalizedExposePath === normalizedRelativeEntryPath);
+    const extensionlessMatch = exposeEntries.find(({ normalizedExposePath })=>removePathExtension(normalizedExposePath) === removePathExtension(normalizedRelativeEntryPath));
+    const exposedMatchedKey = (null == exactMatch ? void 0 : exactMatch.exposeKey) ?? (null == extensionlessMatch ? void 0 : extensionlessMatch.exposeKey);
     if (exposedMatchedKey) {
         let exposedName = exposedMatchedKey;
         if (exposedName.startsWith('./')) exposedName = exposedName.slice(2);
@@ -144,8 +125,20 @@ function getBundlePath(entryPoint, projectRoot, exposes, isUsingMFBundleCommand)
     }
     throw new ConfigError(`Unable to handle entry point: ${relativeEntryPath}. Expected to match an entrypoint with one of the exposed keys, but failed. This is most likely a configuration error. If you believe this is not a configuration issue, please report it as a bug. Debug info: entryPoint="${entryPoint}", projectRoot="${projectRoot}", exposesKeys=[${Object.keys(exposes).join(', ')}]`);
 }
+function normalizeEntryPath(value) {
+    const normalized = toPosixPath(node_path.normalize(value));
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+function removePathExtension(value) {
+    const parsed = node_path.posix.parse(value);
+    return node_path.posix.format({
+        dir: parsed.dir,
+        name: parsed.name,
+        ext: ''
+    });
+}
 function getBundleCode(entryPoint, preModules, graph, options) {
-    const { code } = bundleToString_default()(baseJSBundle_default()(entryPoint, preModules, graph, options));
+    const { code } = bundleToString(baseJSBundle(entryPoint, preModules, graph, options));
     return code;
 }
 export { getModuleFederationSerializer };

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