@module-federation/dts-plugin 0.11.1 → 0.11.3

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -83,7 +83,13 @@ var __async = (__this, __arguments, generator) => {
 // packages/dts-plugin/src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DtsPlugin: () => DtsPlugin
+  DtsPlugin: () => DtsPlugin,
+  consumeTypesAPI: () => consumeTypesAPI,
+  generateTypesAPI: () => generateTypesAPI,
+  isTSProject: () => isTSProject,
+  normalizeConsumeTypesOptions: () => normalizeConsumeTypesOptions,
+  normalizeDtsOptions: () => normalizeDtsOptions,
+  normalizeGenerateTypesOptions: () => normalizeGenerateTypesOptions
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -366,7 +372,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 WEB_CLIENT_OPTIONS_IDENTIFIER = "__WEB_CLIENT_OPTIONS__";
 var UpdateMode;
 (function(UpdateMode2) {
@@ -1206,6 +1212,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;
           }
@@ -1275,6 +1282,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
@@ -1282,15 +1290,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);
@@ -2549,52 +2580,68 @@ var import_sdk11 = require("@module-federation/sdk");
 // packages/dts-plugin/src/plugins/ConsumeTypesPlugin.ts
 var import_sdk8 = require("@module-federation/sdk");
 var import_sdk9 = require("@module-federation/sdk");
+var DEFAULT_CONSUME_TYPES = {
+  abortOnError: false,
+  consumeAPITypes: true
+};
+var normalizeConsumeTypesOptions = /* @__PURE__ */ __name(({ context, dtsOptions, pluginOptions }) => {
+  const normalizedConsumeTypes = (0, import_sdk9.normalizeOptions)(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, defaultOptions3, 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 = defaultOptions3;
     this.fetchRemoteTypeUrlsResolve = fetchRemoteTypeUrlsResolve;
   }
   apply(compiler) {
-    const { dtsOptions, defaultOptions: defaultOptions3, pluginOptions, fetchRemoteTypeUrlsResolve } = this;
+    const { dtsOptions, pluginOptions, fetchRemoteTypeUrlsResolve } = this;
     if (isPrd()) {
       fetchRemoteTypeUrlsResolve(void 0);
       return;
     }
-    const normalizedConsumeTypes = (0, import_sdk9.normalizeOptions)(true, defaultOptions3, "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);
     import_sdk8.logger.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",
@@ -2616,70 +2663,89 @@ var ConsumeTypesPlugin = _ConsumeTypesPlugin;
 var import_fs4 = __toESM(require("fs"));
 var import_path10 = __toESM(require("path"));
 var import_sdk10 = require("@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 = (0, import_sdk10.normalizeOptions)(true, DEFAULT_GENERATE_TYPES, "mfOptions.dts.generateTypes")(dtsOptions.generateTypes);
+  if (!normalizedGenerateTypes) {
+    return;
+  }
+  const normalizedConsumeTypes = (0, import_sdk10.normalizeOptions)(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, defaultOptions3, 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 = defaultOptions3;
     this.fetchRemoteTypeUrlsPromise = fetchRemoteTypeUrlsPromise;
     this.callback = callback;
   }
   apply(compiler) {
-    const { dtsOptions, defaultOptions: defaultOptions3, pluginOptions, fetchRemoteTypeUrlsPromise, callback } = this;
-    const normalizedGenerateTypes = (0, import_sdk10.normalizeOptions)(true, defaultOptions3, "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 = (0, import_sdk10.normalizeOptions)(true, defaultOptions3, "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;
         }
         import_sdk10.logger.debug("start generating types...");
-        yield generateTypesFn(finalOptions);
+        yield generateTypesAPI({
+          dtsManagerOptions
+        });
         import_sdk10.logger.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;
@@ -2706,45 +2772,69 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
             const zipContent = import_fs4.default.readFileSync(zipTypesPath);
             const zipOutputPath = import_path10.default.join(compiler.outputPath, zipPrefix, zipName);
             yield new Promise((resolve5, reject) => {
-              compiler.outputFileSystem.mkdir(import_path10.default.dirname(zipOutputPath), (err) => {
-                if (err && !isEEXIST(err)) {
-                  reject(err);
-                } else {
-                  compiler.outputFileSystem.writeFile(zipOutputPath, zipContent, (writeErr) => {
-                    if (writeErr && !isEEXIST(writeErr)) {
-                      reject(writeErr);
-                    } else {
-                      resolve5();
-                    }
-                  });
+              compiler.outputFileSystem.mkdir(
+                import_path10.default.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 {
+                          resolve5();
+                        }
+                      }
+                    );
+                  }
                 }
-              });
+              );
             });
           }
           if (apiTypesPath) {
             const apiContent = import_fs4.default.readFileSync(apiTypesPath);
             const apiOutputPath = import_path10.default.join(compiler.outputPath, zipPrefix, apiFileName);
             yield new Promise((resolve5, reject) => {
-              compiler.outputFileSystem.mkdir(import_path10.default.dirname(apiOutputPath), (err) => {
-                if (err && !isEEXIST(err)) {
-                  reject(err);
-                } else {
-                  compiler.outputFileSystem.writeFile(apiOutputPath, apiContent, (writeErr) => {
-                    if (writeErr && !isEEXIST(writeErr)) {
-                      reject(writeErr);
-                    } else {
-                      resolve5();
-                    }
-                  });
+              compiler.outputFileSystem.mkdir(
+                import_path10.default.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 {
+                          resolve5();
+                        }
+                      }
+                    );
+                  }
                 }
-              });
+              );
             });
           }
           callback();
         }
       } catch (err) {
         callback();
-        if (finalOptions.displayErrorInTerminal) {
+        if (dtsManagerOptions.displayErrorInTerminal) {
           console.error("Error in mf:generateTypes processAssets hook:", err);
         }
         import_sdk10.logger.debug("generate types fail!");
@@ -2771,6 +2861,14 @@ __name(_GenerateTypesPlugin, "GenerateTypesPlugin");
 var GenerateTypesPlugin = _GenerateTypesPlugin;
 
 // packages/dts-plugin/src/plugins/DtsPlugin.ts
+var normalizeDtsOptions = /* @__PURE__ */ __name((options, context, defaultOptions3) => {
+  return (0, import_sdk11.normalizeOptions)(isTSProject(options.dts, context), {
+    generateTypes: (defaultOptions3 == null ? void 0 : defaultOptions3.defaultGenerateOptions) || DEFAULT_GENERATE_TYPES,
+    consumeTypes: (defaultOptions3 == null ? void 0 : defaultOptions3.defaultConsumeOptions) || DEFAULT_CONSUME_TYPES,
+    extraOptions: {},
+    displayErrorInTerminal: true
+  }, "mfOptions.dts")(options.dts);
+}, "normalizeDtsOptions");
 var _DtsPlugin = class _DtsPlugin {
   constructor(options) {
     __publicField(this, "options");
@@ -2778,23 +2876,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 = (0, import_sdk11.normalizeOptions)(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;
     }
@@ -2807,13 +2889,19 @@ var _DtsPlugin = class _DtsPlugin {
       generateTypesPromiseResolve = resolve5;
     });
     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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DtsPlugin
+  DtsPlugin,
+  consumeTypesAPI,
+  generateTypesAPI,
+  isTSProject,
+  normalizeConsumeTypesOptions,
+  normalizeDtsOptions,
+  normalizeGenerateTypesOptions
 });

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/dts-plugin",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "author": "hanric <hanric.zhang@gmail.com>",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -73,7 +73,7 @@
     "vue": "^3.4.29",
     "@vue/tsconfig": "^0.5.1",
     "vue-tsc": "^2.0.26",
-    "rimraf": "~3.0.2"
+    "rimraf": "~6.0.1"
   },
   "peerDependencies": {
     "typescript": "^4.9.0 || ^5.0.0",

package/dist/start-broker.js

@@ -65,7 +65,7 @@ var import_http = require("http");
 // 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";

package/dist/utils-0ec746b7.d.ts

@@ -0,0 +1,16 @@
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import { H as HostOptions, a as RemoteOptions } from './DTSManagerOptions-c74c59ed.js';
+import { D as DTSManager } from './DTSManager-81645796.js';
+
+declare function getDTSManagerConstructor(implementation?: string): typeof DTSManager;
+declare const validateOptions: (options: HostOptions) => void;
+declare function retrieveTypesAssetsInfo(options: RemoteOptions): {
+    zipPrefix: string;
+    apiTypesPath: string;
+    zipTypesPath: string;
+    zipName: string;
+    apiFileName: string;
+};
+declare const isTSProject: (dtsOptions: moduleFederationPlugin.ModuleFederationPluginOptions["dts"], context?: string) => boolean;
+
+export { getDTSManagerConstructor as g, isTSProject as i, retrieveTypesAssetsInfo as r, validateOptions as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/dts-plugin",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "author": "hanric <hanric.zhang@gmail.com>",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -60,10 +60,10 @@
     "log4js": "6.9.1",
     "node-schedule": "2.1.1",
     "ws": "8.18.0",
-    "@module-federation/sdk": "0.11.1",
-    "@module-federation/managers": "0.11.1",
-    "@module-federation/third-party-dts-extractor": "0.11.1",
-    "@module-federation/error-codes": "0.11.1"
+    "@module-federation/sdk": "0.11.3",
+    "@module-federation/managers": "0.11.3",
+    "@module-federation/third-party-dts-extractor": "0.11.3",
+    "@module-federation/error-codes": "0.11.3"
   },
   "devDependencies": {
     "@types/ws": "8.5.12",
@@ -72,8 +72,8 @@
     "vue": "^3.4.29",
     "@vue/tsconfig": "^0.5.1",
     "vue-tsc": "^2.0.26",
-    "rimraf": "~3.0.2",
-    "@module-federation/runtime": "0.11.1"
+    "rimraf": "~6.0.1",
+    "@module-federation/runtime": "0.11.3"
   },
   "peerDependencies": {
     "typescript": "^4.9.0 || ^5.0.0",