@module-federation/dts-plugin 0.11.1 → 0.11.3

package/dist/esm/index.js

@@ -2,18 +2,18 @@ import {
   consumeTypes,
   generateTypesInChildProcess,
   rpc_exports
-} from "./chunk-UUXLCZNG.js";
+} from "./chunk-GX5A7XT2.js";
 import {
   cloneDeepOptions,
   generateTypes,
   isTSProject,
   retrieveTypesAssetsInfo,
   validateOptions
-} from "./chunk-4XJKD7QF.js";
+} from "./chunk-A4MGPQ34.js";
 import {
   getIPV4,
   logger
-} from "./chunk-KCWHOFI6.js";
+} from "./chunk-56UE3H52.js";
 import {
   WEB_CLIENT_OPTIONS_IDENTIFIER,
   __async,
@@ -21,7 +21,7 @@ import {
   __publicField,
   __spreadProps,
   __spreadValues
-} from "./chunk-4CSLH7II.js";
+} from "./chunk-SPSJLB6F.js";
 
 // packages/dts-plugin/src/plugins/DevPlugin.ts
 import fs from "fs-extra";
@@ -283,52 +283,68 @@ import { normalizeOptions as normalizeOptions4 } from "@module-federation/sdk";
 // packages/dts-plugin/src/plugins/ConsumeTypesPlugin.ts
 import { logger as logger2 } from "@module-federation/sdk";
 import { normalizeOptions as normalizeOptions2 } from "@module-federation/sdk";
+var DEFAULT_CONSUME_TYPES = {
+  abortOnError: false,
+  consumeAPITypes: true
+};
+var normalizeConsumeTypesOptions = /* @__PURE__ */ __name(({ context, dtsOptions, pluginOptions }) => {
+  const normalizedConsumeTypes = normalizeOptions2(true, DEFAULT_CONSUME_TYPES, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
+  if (!normalizedConsumeTypes) {
+    return;
+  }
+  const dtsManagerOptions = {
+    host: __spreadValues({
+      implementation: dtsOptions.implementation,
+      context,
+      moduleFederationConfig: pluginOptions
+    }, normalizedConsumeTypes),
+    extraOptions: dtsOptions.extraOptions || {},
+    displayErrorInTerminal: dtsOptions.displayErrorInTerminal
+  };
+  validateOptions(dtsManagerOptions.host);
+  return dtsManagerOptions;
+}, "normalizeConsumeTypesOptions");
+var consumeTypesAPI = /* @__PURE__ */ __name((dtsManagerOptions, cb) => __async(void 0, null, function* () {
+  const fetchRemoteTypeUrlsPromise = typeof dtsManagerOptions.host.remoteTypeUrls === "function" ? dtsManagerOptions.host.remoteTypeUrls() : Promise.resolve(dtsManagerOptions.host.remoteTypeUrls);
+  return fetchRemoteTypeUrlsPromise.then((remoteTypeUrls) => {
+    consumeTypes(__spreadProps(__spreadValues({}, dtsManagerOptions), {
+      host: __spreadProps(__spreadValues({}, dtsManagerOptions.host), {
+        remoteTypeUrls
+      })
+    })).then(() => {
+      typeof cb === "function" && cb(remoteTypeUrls);
+    }).catch(() => {
+      typeof cb === "function" && cb(remoteTypeUrls);
+    });
+  });
+}), "consumeTypesAPI");
 var _ConsumeTypesPlugin = class _ConsumeTypesPlugin {
-  constructor(pluginOptions, dtsOptions, defaultOptions, fetchRemoteTypeUrlsResolve) {
+  constructor(pluginOptions, dtsOptions, fetchRemoteTypeUrlsResolve) {
     __publicField(this, "pluginOptions");
     __publicField(this, "dtsOptions");
-    __publicField(this, "defaultOptions");
     __publicField(this, "callback");
     __publicField(this, "fetchRemoteTypeUrlsResolve");
     this.pluginOptions = pluginOptions;
     this.dtsOptions = dtsOptions;
-    this.defaultOptions = defaultOptions;
     this.fetchRemoteTypeUrlsResolve = fetchRemoteTypeUrlsResolve;
   }
   apply(compiler) {
-    const { dtsOptions, defaultOptions, pluginOptions, fetchRemoteTypeUrlsResolve } = this;
+    const { dtsOptions, pluginOptions, fetchRemoteTypeUrlsResolve } = this;
     if (isPrd()) {
       fetchRemoteTypeUrlsResolve(void 0);
       return;
     }
-    const normalizedConsumeTypes = normalizeOptions2(true, defaultOptions, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
-    if (!normalizedConsumeTypes) {
+    const dtsManagerOptions = normalizeConsumeTypesOptions({
+      context: compiler.context,
+      dtsOptions,
+      pluginOptions
+    });
+    if (!dtsManagerOptions) {
       fetchRemoteTypeUrlsResolve(void 0);
       return;
     }
-    const finalOptions = {
-      host: __spreadValues({
-        implementation: dtsOptions.implementation,
-        context: compiler.context,
-        moduleFederationConfig: pluginOptions
-      }, normalizedConsumeTypes),
-      extraOptions: dtsOptions.extraOptions || {},
-      displayErrorInTerminal: dtsOptions.displayErrorInTerminal
-    };
-    validateOptions(finalOptions.host);
-    const fetchRemoteTypeUrlsPromise = typeof normalizedConsumeTypes.remoteTypeUrls === "function" ? normalizedConsumeTypes.remoteTypeUrls() : Promise.resolve(normalizedConsumeTypes.remoteTypeUrls);
     logger2.debug("start fetching remote types...");
-    const promise = fetchRemoteTypeUrlsPromise.then((remoteTypeUrls) => {
-      consumeTypes(__spreadProps(__spreadValues({}, finalOptions), {
-        host: __spreadProps(__spreadValues({}, finalOptions.host), {
-          remoteTypeUrls
-        })
-      })).then(() => {
-        fetchRemoteTypeUrlsResolve(remoteTypeUrls);
-      }).catch(() => {
-        fetchRemoteTypeUrlsResolve(remoteTypeUrls);
-      });
-    });
+    const promise = consumeTypesAPI(dtsManagerOptions, fetchRemoteTypeUrlsResolve);
     compiler.hooks.thisCompilation.tap("mf:generateTypes", (compilation) => {
       compilation.hooks.processAssets.tapPromise({
         name: "mf:generateTypes",
@@ -350,70 +366,89 @@ var ConsumeTypesPlugin = _ConsumeTypesPlugin;
 import fs2 from "fs";
 import path5 from "path";
 import { logger as logger3, normalizeOptions as normalizeOptions3 } from "@module-federation/sdk";
+var DEFAULT_GENERATE_TYPES = {
+  generateAPITypes: true,
+  compileInChildProcess: true,
+  abortOnError: false,
+  extractThirdParty: false,
+  extractRemoteTypes: false
+};
+var normalizeGenerateTypesOptions = /* @__PURE__ */ __name(({ context, outputDir, dtsOptions, pluginOptions }) => {
+  const normalizedGenerateTypes = normalizeOptions3(true, DEFAULT_GENERATE_TYPES, "mfOptions.dts.generateTypes")(dtsOptions.generateTypes);
+  if (!normalizedGenerateTypes) {
+    return;
+  }
+  const normalizedConsumeTypes = normalizeOptions3(true, {}, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
+  const finalOptions = {
+    remote: __spreadValues({
+      implementation: dtsOptions.implementation,
+      context,
+      outputDir,
+      moduleFederationConfig: pluginOptions
+    }, normalizedGenerateTypes),
+    host: normalizedConsumeTypes === false ? void 0 : __spreadValues({
+      context,
+      moduleFederationConfig: pluginOptions
+    }, normalizedGenerateTypes),
+    extraOptions: dtsOptions.extraOptions || {},
+    displayErrorInTerminal: dtsOptions.displayErrorInTerminal
+  };
+  if (dtsOptions.tsConfigPath && !finalOptions.remote.tsConfigPath) {
+    finalOptions.remote.tsConfigPath = dtsOptions.tsConfigPath;
+  }
+  validateOptions(finalOptions.remote);
+  return finalOptions;
+}, "normalizeGenerateTypesOptions");
+var getGenerateTypesFn = /* @__PURE__ */ __name((dtsManagerOptions) => {
+  let fn = generateTypes;
+  if (dtsManagerOptions.remote.compileInChildProcess) {
+    fn = generateTypesInChildProcess;
+  }
+  return fn;
+}, "getGenerateTypesFn");
+var generateTypesAPI = /* @__PURE__ */ __name(({ dtsManagerOptions }) => {
+  const fn = getGenerateTypesFn(dtsManagerOptions);
+  return fn(dtsManagerOptions);
+}, "generateTypesAPI");
 var _GenerateTypesPlugin = class _GenerateTypesPlugin {
-  constructor(pluginOptions, dtsOptions, defaultOptions, fetchRemoteTypeUrlsPromise, callback) {
+  constructor(pluginOptions, dtsOptions, fetchRemoteTypeUrlsPromise, callback) {
     __publicField(this, "pluginOptions");
     __publicField(this, "dtsOptions");
-    __publicField(this, "defaultOptions");
     __publicField(this, "fetchRemoteTypeUrlsPromise");
     __publicField(this, "callback");
     this.pluginOptions = pluginOptions;
     this.dtsOptions = dtsOptions;
-    this.defaultOptions = defaultOptions;
     this.fetchRemoteTypeUrlsPromise = fetchRemoteTypeUrlsPromise;
     this.callback = callback;
   }
   apply(compiler) {
-    const { dtsOptions, defaultOptions, pluginOptions, fetchRemoteTypeUrlsPromise, callback } = this;
-    const normalizedGenerateTypes = normalizeOptions3(true, defaultOptions, "mfOptions.dts.generateTypes")(dtsOptions.generateTypes);
-    if (!normalizedGenerateTypes) {
+    const { dtsOptions, pluginOptions, fetchRemoteTypeUrlsPromise, callback } = this;
+    const outputDir = getCompilerOutputDir(compiler);
+    const context = compiler.context;
+    const dtsManagerOptions = normalizeGenerateTypesOptions({
+      context,
+      outputDir,
+      dtsOptions,
+      pluginOptions
+    });
+    if (!dtsManagerOptions) {
       callback();
       return;
     }
-    const normalizedConsumeTypes = normalizeOptions3(true, defaultOptions, "mfOptions.dts.consumeTypes")(dtsOptions.consumeTypes);
-    const finalOptions = {
-      remote: __spreadValues({
-        implementation: dtsOptions.implementation,
-        context: compiler.context,
-        outputDir: getCompilerOutputDir(compiler),
-        moduleFederationConfig: pluginOptions
-      }, normalizedGenerateTypes),
-      host: normalizedConsumeTypes === false ? void 0 : __spreadValues({
-        context: compiler.context,
-        moduleFederationConfig: pluginOptions
-      }, normalizedGenerateTypes),
-      extraOptions: dtsOptions.extraOptions || {},
-      displayErrorInTerminal: dtsOptions.displayErrorInTerminal
-    };
-    if (dtsOptions.tsConfigPath && !finalOptions.remote.tsConfigPath) {
-      finalOptions.remote.tsConfigPath = dtsOptions.tsConfigPath;
-    }
-    validateOptions(finalOptions.remote);
     const isProd = !isDev();
-    const getGenerateTypesFn = /* @__PURE__ */ __name(() => {
-      let fn = generateTypes;
-      let res;
-      if (finalOptions.remote.compileInChildProcess) {
-        fn = generateTypesInChildProcess;
-      }
-      if (isProd) {
-        res = fn(finalOptions);
-        return () => res;
-      }
-      return fn;
-    }, "getGenerateTypesFn");
-    const generateTypesFn = getGenerateTypesFn();
     const emitTypesFiles = /* @__PURE__ */ __name((compilation) => __async(this, null, function* () {
       try {
-        const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(finalOptions.remote);
+        const { zipTypesPath, apiTypesPath, zipName, apiFileName } = retrieveTypesAssetsInfo(dtsManagerOptions.remote);
         if (isProd && zipName && compilation.getAsset(zipName)) {
           callback();
           return;
         }
         logger3.debug("start generating types...");
-        yield generateTypesFn(finalOptions);
+        yield generateTypesAPI({
+          dtsManagerOptions
+        });
         logger3.debug("generate types success!");
-        const config = finalOptions.remote.moduleFederationConfig;
+        const config = dtsManagerOptions.remote.moduleFederationConfig;
         let zipPrefix = "";
         if (typeof config.manifest === "object" && config.manifest.filePath) {
           zipPrefix = config.manifest.filePath;
@@ -440,45 +475,69 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
             const zipContent = fs2.readFileSync(zipTypesPath);
             const zipOutputPath = path5.join(compiler.outputPath, zipPrefix, zipName);
             yield new Promise((resolve2, reject) => {
-              compiler.outputFileSystem.mkdir(path5.dirname(zipOutputPath), (err) => {
-                if (err && !isEEXIST(err)) {
-                  reject(err);
-                } else {
-                  compiler.outputFileSystem.writeFile(zipOutputPath, zipContent, (writeErr) => {
-                    if (writeErr && !isEEXIST(writeErr)) {
-                      reject(writeErr);
-                    } else {
-                      resolve2();
-                    }
-                  });
+              compiler.outputFileSystem.mkdir(
+                path5.dirname(zipOutputPath),
+                {
+                  recursive: true
+                },
+                // @ts-ignore  type fixed in  https://github.com/webpack/webpack/releases/tag/v5.91.0
+                (err) => {
+                  if (err && !isEEXIST(err)) {
+                    reject(err);
+                  } else {
+                    compiler.outputFileSystem.writeFile(
+                      zipOutputPath,
+                      // @ts-ignore
+                      zipContent,
+                      (writeErr) => {
+                        if (writeErr && !isEEXIST(writeErr)) {
+                          reject(writeErr);
+                        } else {
+                          resolve2();
+                        }
+                      }
+                    );
+                  }
                 }
-              });
+              );
             });
           }
           if (apiTypesPath) {
             const apiContent = fs2.readFileSync(apiTypesPath);
             const apiOutputPath = path5.join(compiler.outputPath, zipPrefix, apiFileName);
             yield new Promise((resolve2, reject) => {
-              compiler.outputFileSystem.mkdir(path5.dirname(apiOutputPath), (err) => {
-                if (err && !isEEXIST(err)) {
-                  reject(err);
-                } else {
-                  compiler.outputFileSystem.writeFile(apiOutputPath, apiContent, (writeErr) => {
-                    if (writeErr && !isEEXIST(writeErr)) {
-                      reject(writeErr);
-                    } else {
-                      resolve2();
-                    }
-                  });
+              compiler.outputFileSystem.mkdir(
+                path5.dirname(apiOutputPath),
+                {
+                  recursive: true
+                },
+                // @ts-ignore  type fixed in  https://github.com/webpack/webpack/releases/tag/v5.91.0
+                (err) => {
+                  if (err && !isEEXIST(err)) {
+                    reject(err);
+                  } else {
+                    compiler.outputFileSystem.writeFile(
+                      apiOutputPath,
+                      // @ts-ignore
+                      apiContent,
+                      (writeErr) => {
+                        if (writeErr && !isEEXIST(writeErr)) {
+                          reject(writeErr);
+                        } else {
+                          resolve2();
+                        }
+                      }
+                    );
+                  }
                 }
-              });
+              );
             });
           }
           callback();
         }
       } catch (err) {
         callback();
-        if (finalOptions.displayErrorInTerminal) {
+        if (dtsManagerOptions.displayErrorInTerminal) {
           console.error("Error in mf:generateTypes processAssets hook:", err);
         }
         logger3.debug("generate types fail!");
@@ -505,6 +564,14 @@ __name(_GenerateTypesPlugin, "GenerateTypesPlugin");
 var GenerateTypesPlugin = _GenerateTypesPlugin;
 
 // packages/dts-plugin/src/plugins/DtsPlugin.ts
+var normalizeDtsOptions = /* @__PURE__ */ __name((options, context, defaultOptions) => {
+  return normalizeOptions4(isTSProject(options.dts, context), {
+    generateTypes: (defaultOptions == null ? void 0 : defaultOptions.defaultGenerateOptions) || DEFAULT_GENERATE_TYPES,
+    consumeTypes: (defaultOptions == null ? void 0 : defaultOptions.defaultConsumeOptions) || DEFAULT_CONSUME_TYPES,
+    extraOptions: {},
+    displayErrorInTerminal: true
+  }, "mfOptions.dts")(options.dts);
+}, "normalizeDtsOptions");
 var _DtsPlugin = class _DtsPlugin {
   constructor(options) {
     __publicField(this, "options");
@@ -512,23 +579,7 @@ var _DtsPlugin = class _DtsPlugin {
   }
   apply(compiler) {
     const { options } = this;
-    const defaultGenerateTypes = {
-      generateAPITypes: true,
-      compileInChildProcess: true,
-      abortOnError: false,
-      extractThirdParty: false,
-      extractRemoteTypes: false
-    };
-    const defaultConsumeTypes = {
-      abortOnError: false,
-      consumeAPITypes: true
-    };
-    const normalizedDtsOptions = normalizeOptions4(isTSProject(options.dts, compiler.context), {
-      generateTypes: defaultGenerateTypes,
-      consumeTypes: defaultConsumeTypes,
-      extraOptions: {},
-      displayErrorInTerminal: true
-    }, "mfOptions.dts")(options.dts);
+    const normalizedDtsOptions = normalizeDtsOptions(options, compiler.context);
     if (typeof normalizedDtsOptions !== "object") {
       return;
     }
@@ -541,12 +592,18 @@ var _DtsPlugin = class _DtsPlugin {
       generateTypesPromiseResolve = resolve2;
     });
     new DevPlugin(options, normalizedDtsOptions, generateTypesPromise, fetchRemoteTypeUrlsPromise).apply(compiler);
-    new GenerateTypesPlugin(options, normalizedDtsOptions, defaultGenerateTypes, fetchRemoteTypeUrlsPromise, generateTypesPromiseResolve).apply(compiler);
-    new ConsumeTypesPlugin(options, normalizedDtsOptions, defaultConsumeTypes, fetchRemoteTypeUrlsResolve).apply(compiler);
+    new GenerateTypesPlugin(options, normalizedDtsOptions, fetchRemoteTypeUrlsPromise, generateTypesPromiseResolve).apply(compiler);
+    new ConsumeTypesPlugin(options, normalizedDtsOptions, fetchRemoteTypeUrlsResolve).apply(compiler);
   }
 };
 __name(_DtsPlugin, "DtsPlugin");
 var DtsPlugin = _DtsPlugin;
 export {
-  DtsPlugin
+  DtsPlugin,
+  consumeTypesAPI,
+  generateTypesAPI,
+  isTSProject,
+  normalizeConsumeTypesOptions,
+  normalizeDtsOptions,
+  normalizeGenerateTypesOptions
 };

package/dist/esm/start-broker.js

@@ -1,11 +1,11 @@
 import {
   Broker,
   fileLog
-} from "./chunk-KCWHOFI6.js";
+} from "./chunk-56UE3H52.js";
 import {
   __async,
   __name
-} from "./chunk-4CSLH7II.js";
+} from "./chunk-SPSJLB6F.js";
 
 // packages/dts-plugin/src/server/broker/startBroker.ts
 var broker;

package/dist/fork-dev-worker.js

@@ -354,7 +354,7 @@ var log4js = __toESM(require("log4js"));
 // packages/dts-plugin/src/server/constant.ts
 var DEFAULT_WEB_SOCKET_PORT = 16322;
 var WEB_SOCKET_CONNECT_MAGIC_ID = "1hpzW-zo2z-o8io-gfmV1-2cb1d82";
-var MF_SERVER_IDENTIFIER = "Module Federation Dev Server";
+var MF_SERVER_IDENTIFIER = "Module Federation DTS";
 var DEFAULT_TAR_NAME = "@mf-types.zip";
 var UpdateMode;
 (function(UpdateMode2) {
@@ -1703,6 +1703,7 @@ var downloadTypesArchive = /* @__PURE__ */ __name((hostOptions) => {
       } catch (error2) {
         fileLog(`Error during types archive download: ${(error2 == null ? void 0 : error2.message) || "unknown error"}`, "downloadTypesArchive", "error");
         if (retries >= hostOptions.maxRetries) {
+          logger.error(`Failed to download ${fileToDownload}, you can set FEDERATION_DEBUG=true to see detail message.`);
           if (hostOptions.abortOnError !== false) {
             throw error2;
           }
@@ -1772,6 +1773,7 @@ var retrieveRemoteInfo = /* @__PURE__ */ __name((options) => {
   };
 }, "retrieveRemoteInfo");
 var resolveRemotes = /* @__PURE__ */ __name((hostOptions) => {
+  var _a3;
   const parsedOptions = import_managers.utils.parseOptions(hostOptions.moduleFederationConfig.remotes || {}, (item, key) => ({
     remote: Array.isArray(item) ? item[0] : item,
     key
@@ -1779,15 +1781,38 @@ var resolveRemotes = /* @__PURE__ */ __name((hostOptions) => {
     remote: Array.isArray(item.external) ? item.external[0] : item.external,
     key
   }));
+  const remoteTypeUrls = (_a3 = hostOptions.remoteTypeUrls) != null ? _a3 : {};
+  if (typeof remoteTypeUrls !== "object") {
+    throw new Error("remoteTypeUrls must be consumed before resolveRemotes");
+  }
+  const remoteInfos = Object.keys(remoteTypeUrls).reduce((sum, remoteName) => {
+    const { zip, api, alias } = remoteTypeUrls[remoteName];
+    sum[alias] = {
+      name: remoteName,
+      url: "",
+      zipUrl: zip,
+      apiTypeUrl: api,
+      alias: alias || remoteName
+    };
+    return sum;
+  }, {});
   return parsedOptions.reduce((accumulator, item) => {
     const { key, remote } = item[1];
-    accumulator[key] = retrieveRemoteInfo({
+    const res = retrieveRemoteInfo({
       hostOptions,
       remoteAlias: key,
       remote
     });
+    if (accumulator[key]) {
+      accumulator[key] = __spreadProps(__spreadValues({}, accumulator[key]), {
+        url: res.url,
+        apiTypeUrl: accumulator[key].apiTypeUrl || res.apiTypeUrl
+      });
+      return accumulator;
+    }
+    accumulator[key] = res;
     return accumulator;
-  }, {});
+  }, remoteInfos);
 }, "resolveRemotes");
 var retrieveHostConfig = /* @__PURE__ */ __name((options) => {
   validateOptions(options);

package/dist/fork-generate-dts.d.mts

@@ -1,7 +1,8 @@
-import { k as DtsWorkerOptions } from './DtsWorker-bfe21fe7.js';
+import { j as DtsWorkerOptions } from './DtsWorker-c39c84fb.js';
 import 'child_process';
 import './DTSManagerOptions-c74c59ed.js';
 import '@module-federation/sdk';
+import './DTSManager-81645796.js';
 import 'typescript';
 
 declare function forkGenerateDts(options: DtsWorkerOptions): Promise<void>;

package/dist/fork-generate-dts.d.ts

@@ -1,7 +1,8 @@
-import { k as DtsWorkerOptions } from './DtsWorker-bfe21fe7.js';
+import { j as DtsWorkerOptions } from './DtsWorker-c39c84fb.js';
 import 'child_process';
 import './DTSManagerOptions-c74c59ed.js';
 import '@module-federation/sdk';
+import './DTSManager-81645796.js';
 import 'typescript';
 
 declare function forkGenerateDts(options: DtsWorkerOptions): Promise<void>;

package/dist/fork-generate-dts.js

@@ -538,7 +538,7 @@ var log4js = __toESM(require("log4js"));
 // packages/dts-plugin/src/server/constant.ts
 var DEFAULT_WEB_SOCKET_PORT = 16322;
 var WEB_SOCKET_CONNECT_MAGIC_ID = "1hpzW-zo2z-o8io-gfmV1-2cb1d82";
-var MF_SERVER_IDENTIFIER = "Module Federation Dev Server";
+var MF_SERVER_IDENTIFIER = "Module Federation DTS";
 var UpdateMode;
 (function(UpdateMode2) {
   UpdateMode2["POSITIVE"] = "POSITIVE";
@@ -1349,6 +1349,7 @@ var downloadTypesArchive = /* @__PURE__ */ __name((hostOptions) => {
       } catch (error2) {
         fileLog(`Error during types archive download: ${(error2 == null ? void 0 : error2.message) || "unknown error"}`, "downloadTypesArchive", "error");
         if (retries >= hostOptions.maxRetries) {
+          logger.error(`Failed to download ${fileToDownload}, you can set FEDERATION_DEBUG=true to see detail message.`);
           if (hostOptions.abortOnError !== false) {
             throw error2;
           }
@@ -1418,6 +1419,7 @@ var retrieveRemoteInfo = /* @__PURE__ */ __name((options) => {
   };
 }, "retrieveRemoteInfo");
 var resolveRemotes = /* @__PURE__ */ __name((hostOptions) => {
+  var _a2;
   const parsedOptions = import_managers2.utils.parseOptions(hostOptions.moduleFederationConfig.remotes || {}, (item, key) => ({
     remote: Array.isArray(item) ? item[0] : item,
     key
@@ -1425,15 +1427,38 @@ var resolveRemotes = /* @__PURE__ */ __name((hostOptions) => {
     remote: Array.isArray(item.external) ? item.external[0] : item.external,
     key
   }));
+  const remoteTypeUrls = (_a2 = hostOptions.remoteTypeUrls) != null ? _a2 : {};
+  if (typeof remoteTypeUrls !== "object") {
+    throw new Error("remoteTypeUrls must be consumed before resolveRemotes");
+  }
+  const remoteInfos = Object.keys(remoteTypeUrls).reduce((sum, remoteName) => {
+    const { zip, api, alias } = remoteTypeUrls[remoteName];
+    sum[alias] = {
+      name: remoteName,
+      url: "",
+      zipUrl: zip,
+      apiTypeUrl: api,
+      alias: alias || remoteName
+    };
+    return sum;
+  }, {});
   return parsedOptions.reduce((accumulator, item) => {
     const { key, remote } = item[1];
-    accumulator[key] = retrieveRemoteInfo({
+    const res = retrieveRemoteInfo({
       hostOptions,
       remoteAlias: key,
       remote
     });
+    if (accumulator[key]) {
+      accumulator[key] = __spreadProps(__spreadValues({}, accumulator[key]), {
+        url: res.url,
+        apiTypeUrl: accumulator[key].apiTypeUrl || res.apiTypeUrl
+      });
+      return accumulator;
+    }
+    accumulator[key] = res;
     return accumulator;
-  }, {});
+  }, remoteInfos);
 }, "resolveRemotes");
 var retrieveHostConfig = /* @__PURE__ */ __name((options) => {
   validateOptions(options);

package/dist/index.d.mts

@@ -1,10 +1,52 @@
 import { moduleFederationPlugin } from '@module-federation/sdk';
 import { WebpackPluginInstance, Compiler } from 'webpack';
+import { D as DTSManagerOptions } from './DTSManagerOptions-c74c59ed.js';
+export { i as isTSProject } from './utils-0ec746b7.js';
+import './DTSManager-81645796.js';
+import 'typescript';
 
+declare const normalizeDtsOptions: (options: moduleFederationPlugin.ModuleFederationPluginOptions, context: string, defaultOptions?: {
+    defaultGenerateOptions?: moduleFederationPlugin.DtsRemoteOptions;
+    defaultConsumeOptions?: moduleFederationPlugin.DtsHostOptions;
+}) => false | moduleFederationPlugin.PluginDtsOptions;
 declare class DtsPlugin implements WebpackPluginInstance {
     options: moduleFederationPlugin.ModuleFederationPluginOptions;
     constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions);
     apply(compiler: Compiler): void;
 }
 
-export { DtsPlugin };
+declare const normalizeConsumeTypesOptions: ({ context, dtsOptions, pluginOptions, }: {
+    context?: string;
+    dtsOptions: moduleFederationPlugin.PluginDtsOptions;
+    pluginOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
+}) => {
+    host: {
+        typesFolder?: string;
+        abortOnError?: boolean;
+        remoteTypesFolder?: string;
+        deleteTypesFolder?: boolean;
+        maxRetries?: number;
+        consumeAPITypes?: boolean;
+        runtimePkgs?: string[];
+        remoteTypeUrls?: (() => Promise<moduleFederationPlugin.RemoteTypeUrls>) | moduleFederationPlugin.RemoteTypeUrls;
+        timeout?: number;
+        implementation: string;
+        context: string;
+        moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    };
+    extraOptions: Record<string, any>;
+    displayErrorInTerminal: boolean;
+};
+declare const consumeTypesAPI: (dtsManagerOptions: DTSManagerOptions, cb?: (options: moduleFederationPlugin.RemoteTypeUrls) => void) => Promise<void>;
+
+declare const normalizeGenerateTypesOptions: ({ context, outputDir, dtsOptions, pluginOptions, }: {
+    context?: string;
+    outputDir?: string;
+    dtsOptions: moduleFederationPlugin.PluginDtsOptions;
+    pluginOptions: moduleFederationPlugin.ModuleFederationPluginOptions;
+}) => DTSManagerOptions;
+declare const generateTypesAPI: ({ dtsManagerOptions, }: {
+    dtsManagerOptions: DTSManagerOptions;
+}) => Promise<void>;
+
+export { DtsPlugin, consumeTypesAPI, generateTypesAPI, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions };