@module-federation/dts-plugin 0.2.6 → 0.2.8

package/dist/fork-generate-dts.js

@@ -147,7 +147,7 @@ __name(exposeRpc, "exposeRpc");
 var import_axios = __toESM(require("axios"));
 var import_http2 = __toESM(require("http"));
 var import_https = __toESM(require("https"));
-var import_ansi_colors3 = __toESM(require("ansi-colors"));
+var import_ansi_colors2 = __toESM(require("ansi-colors"));
 
 // packages/dts-plugin/src/core/configurations/remotePlugin.ts
 var import_fs = require("fs");
@@ -170,20 +170,56 @@ var defaultOptions = {
   extractRemoteTypes: false,
   extractThirdParty: false
 };
-var readTsConfig = /* @__PURE__ */ __name(({ tsConfigPath, typesFolder, compiledTypesFolder, context }) => {
+function getEffectiveRootDir(parsedCommandLine) {
+  const compilerOptions = parsedCommandLine.options;
+  if (compilerOptions.rootDir) {
+    return compilerOptions.rootDir;
+  }
+  const files = parsedCommandLine.fileNames;
+  if (files.length > 0) {
+    const commonRoot = files.map((file) => (0, import_path.dirname)(file)).reduce((commonPath, fileDir) => {
+      while (!fileDir.startsWith(commonPath)) {
+        commonPath = (0, import_path.dirname)(commonPath);
+      }
+      return commonPath;
+    }, files[0]);
+    return commonRoot;
+  }
+  throw new Error("Can not get effective rootDir, please set compilerOptions.rootDir !");
+}
+__name(getEffectiveRootDir, "getEffectiveRootDir");
+var readTsConfig = /* @__PURE__ */ __name(({ tsConfigPath, typesFolder, compiledTypesFolder, context, additionalFilesToCompile }, mapComponentsToExpose) => {
   const resolvedTsConfigPath = (0, import_path.resolve)(context, tsConfigPath);
   const readResult = import_typescript.default.readConfigFile(resolvedTsConfigPath, import_typescript.default.sys.readFile);
   if (readResult.error) {
     throw new Error(readResult.error.messageText.toString());
   }
-  const configContent = import_typescript.default.parseJsonConfigFileContent(readResult.config, import_typescript.default.sys, (0, import_path.dirname)(resolvedTsConfigPath));
+  const rawTsConfigJson = readResult.config;
+  const configContent = import_typescript.default.parseJsonConfigFileContent(rawTsConfigJson, import_typescript.default.sys, (0, import_path.dirname)(resolvedTsConfigPath));
+  const rootDir = getEffectiveRootDir(configContent);
   const outDir = (0, import_path.resolve)(context, configContent.options.outDir || "dist", typesFolder, compiledTypesFolder);
-  return __spreadProps(__spreadValues({}, configContent.options), {
+  const defaultCompilerOptions = {
+    rootDir,
     emitDeclarationOnly: true,
     noEmit: false,
     declaration: true,
     outDir
-  });
+  };
+  rawTsConfigJson.compilerOptions = rawTsConfigJson.compilerOptions || {};
+  rawTsConfigJson.compilerOptions = __spreadValues(__spreadValues({}, rawTsConfigJson.compilerOptions), defaultCompilerOptions);
+  const filesToCompile = [
+    ...Object.values(mapComponentsToExpose),
+    ...additionalFilesToCompile
+  ];
+  rawTsConfigJson.include = [];
+  rawTsConfigJson.files = filesToCompile;
+  rawTsConfigJson.exclude = [];
+  "references" in rawTsConfigJson && delete rawTsConfigJson.references;
+  const extendsPath = rawTsConfigJson.extends;
+  if (extendsPath && extendsPath.startsWith(".")) {
+    rawTsConfigJson.extends = (0, import_path.resolve)(context, extendsPath);
+  }
+  return rawTsConfigJson;
 }, "readTsConfig");
 var TS_EXTENSIONS = [
   "ts",
@@ -221,7 +257,7 @@ var retrieveRemoteConfig = /* @__PURE__ */ __name((options) => {
   validateOptions(options);
   const remoteOptions = __spreadValues(__spreadValues({}, defaultOptions), options);
   const mapComponentsToExpose = resolveExposes(remoteOptions);
-  const tsConfig = readTsConfig(remoteOptions);
+  const tsConfig = readTsConfig(remoteOptions, mapComponentsToExpose);
   return {
     tsConfig,
     mapComponentsToExpose,
@@ -230,95 +266,131 @@ var retrieveRemoteConfig = /* @__PURE__ */ __name((options) => {
 }, "retrieveRemoteConfig");
 
 // packages/dts-plugin/src/core/lib/DTSManager.ts
-var import_ansi_colors2 = __toESM(require("ansi-colors"));
+var import_ansi_colors = __toESM(require("ansi-colors"));
 var import_path4 = __toESM(require("path"));
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_fs2 = __toESM(require("fs"));
-var import_sdk4 = require("@module-federation/sdk");
+var import_sdk5 = require("@module-federation/sdk");
 var import_lodash2 = __toESM(require("lodash.clonedeepwith"));
 var import_third_party_dts_extractor2 = require("@module-federation/third-party-dts-extractor");
 
 // packages/dts-plugin/src/core/lib/archiveHandler.ts
 var import_adm_zip = __toESM(require("adm-zip"));
 var import_path3 = require("path");
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 
 // packages/dts-plugin/src/core/lib/typeScriptCompiler.ts
-var import_ansi_colors = __toESM(require("ansi-colors"));
+var import_fs_extra = require("fs-extra");
+var import_promises = require("fs/promises");
+var import_crypto = require("crypto");
 var import_path2 = require("path");
-var import_typescript2 = __toESM(require("typescript"));
 var import_third_party_dts_extractor = require("@module-federation/third-party-dts-extractor");
+var import_child_process = require("child_process");
+var import_util = __toESM(require("util"));
+var import_sdk = require("@module-federation/sdk");
 var STARTS_WITH_SLASH = /^\//;
 var DEFINITION_FILE_EXTENSION = ".d.ts";
-var reportCompileDiagnostic = /* @__PURE__ */ __name((diagnostic) => {
-  const { line } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-  console.error(import_ansi_colors.default.red(`TS Error ${diagnostic.code}':' ${import_typescript2.default.flattenDiagnosticMessageText(diagnostic.messageText, import_typescript2.default.sys.newLine)}`));
-  console.error(import_ansi_colors.default.red(`         at ${diagnostic.file.fileName}:${line + 1} typescript.sys.newLine`));
-}, "reportCompileDiagnostic");
-var retrieveMfTypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => (0, import_path2.normalize)(tsConfig.outDir.replace(remoteOptions.compiledTypesFolder, "")), "retrieveMfTypesPath");
-var retrieveOriginalOutDir = /* @__PURE__ */ __name((tsConfig, remoteOptions) => (0, import_path2.normalize)(tsConfig.outDir.replace(remoteOptions.compiledTypesFolder, "").replace(remoteOptions.typesFolder, "")), "retrieveOriginalOutDir");
+var retrieveMfTypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => (0, import_path2.normalize)(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "")), "retrieveMfTypesPath");
+var retrieveOriginalOutDir = /* @__PURE__ */ __name((tsConfig, remoteOptions) => (0, import_path2.normalize)(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "").replace(remoteOptions.typesFolder, "")), "retrieveOriginalOutDir");
 var retrieveMfAPITypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => (0, import_path2.join)(retrieveOriginalOutDir(tsConfig, remoteOptions), `${remoteOptions.typesFolder}.d.ts`), "retrieveMfAPITypesPath");
-var createHost = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions, cb) => {
-  const host = import_typescript2.default.createCompilerHost(tsConfig);
-  const originalWriteFile = host.writeFile;
-  const mapExposeToEntry = Object.fromEntries(Object.entries(mapComponentsToExpose).map(([exposed, filename]) => [
-    (0, import_path2.normalize)(filename),
-    exposed
-  ]));
-  const mfTypePath = retrieveMfTypesPath(tsConfig, remoteOptions);
-  host.writeFile = (filepath, text, writeOrderByteMark, onError, sourceFiles, data) => {
-    originalWriteFile(filepath, text, writeOrderByteMark, onError, sourceFiles, data);
-    for (const sourceFile of sourceFiles || []) {
-      let sourceEntry = mapExposeToEntry[(0, import_path2.normalize)(sourceFile.fileName)];
-      if (sourceEntry === ".") {
-        sourceEntry = "index";
-      }
-      if (sourceEntry) {
-        const mfeTypeEntry = (0, import_path2.join)(mfTypePath, `${sourceEntry}${DEFINITION_FILE_EXTENSION}`);
-        const mfeTypeEntryDirectory = (0, import_path2.dirname)(mfeTypeEntry);
-        const relativePathToOutput = (0, import_path2.relative)(mfeTypeEntryDirectory, filepath).replace(DEFINITION_FILE_EXTENSION, "").replace(STARTS_WITH_SLASH, "").split(import_path2.sep).join("/");
-        originalWriteFile(mfeTypeEntry, `export * from './${relativePathToOutput}';
-export { default } from './${relativePathToOutput}';`, writeOrderByteMark);
+function writeTempTsConfig(tsConfig, context) {
+  const tempTsConfigJsonPath = (0, import_path2.resolve)(context, "node_modules", import_sdk.TEMP_DIR, `tsconfig.${(0, import_crypto.randomUUID)()}.json`);
+  (0, import_fs_extra.ensureDirSync)((0, import_path2.dirname)(tempTsConfigJsonPath));
+  (0, import_fs_extra.writeFileSync)(tempTsConfigJsonPath, JSON.stringify(tsConfig, null, 2));
+  return tempTsConfigJsonPath;
+}
+__name(writeTempTsConfig, "writeTempTsConfig");
+var removeExt = /* @__PURE__ */ __name((f) => {
+  const ext = (0, import_path2.extname)(f);
+  const regexPattern = new RegExp(`\\${ext}$`);
+  return f.replace(regexPattern, "");
+}, "removeExt");
+function getExposeKey(options) {
+  const { filePath, rootDir, outDir, mapExposeToEntry } = options;
+  const relativeFilePath = removeExt((0, import_path2.relative)(outDir, filePath.replace(new RegExp(`\\.d.ts$`), "")));
+  return mapExposeToEntry[relativeFilePath];
+}
+__name(getExposeKey, "getExposeKey");
+var processTypesFile = /* @__PURE__ */ __name((options) => __async(void 0, null, function* () {
+  const { outDir, filePath, rootDir, cb, mapExposeToEntry, mfTypePath } = options;
+  if (!(0, import_fs_extra.existsSync)(filePath)) {
+    return;
+  }
+  const stats = yield (0, import_promises.stat)(filePath);
+  if (stats.isDirectory()) {
+    const files = yield (0, import_promises.readdir)(filePath);
+    yield Promise.all(files.map((file) => processTypesFile(__spreadProps(__spreadValues({}, options), {
+      filePath: (0, import_path2.join)(filePath, file)
+    }))));
+  } else if (filePath.endsWith(".d.ts")) {
+    const exposeKey = getExposeKey({
+      filePath,
+      rootDir,
+      outDir,
+      mapExposeToEntry
+    });
+    if (exposeKey) {
+      const sourceEntry = exposeKey === "." ? "index" : exposeKey;
+      const mfeTypeEntry = (0, import_path2.join)(mfTypePath, `${sourceEntry}${DEFINITION_FILE_EXTENSION}`);
+      const mfeTypeEntryDirectory = (0, import_path2.dirname)(mfeTypeEntry);
+      const relativePathToOutput = (0, import_path2.relative)(mfeTypeEntryDirectory, filePath).replace(DEFINITION_FILE_EXTENSION, "").replace(STARTS_WITH_SLASH, "").split(import_path2.sep).join("/");
+      (0, import_fs_extra.ensureDirSync)(mfeTypeEntryDirectory);
+      yield (0, import_promises.writeFile)(mfeTypeEntry, `export * from './${relativePathToOutput}';
+export { default } from './${relativePathToOutput}';`);
+    }
+    const content = yield (0, import_promises.readFile)(filePath, "utf8");
+    cb(content);
+  }
+}), "processTypesFile");
+var compileTs = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions) => __async(void 0, null, function* () {
+  if (!Object.keys(mapComponentsToExpose).length) {
+    return;
+  }
+  const { compilerOptions } = tsConfig;
+  const tempTsConfigJsonPath = writeTempTsConfig(tsConfig, remoteOptions.context);
+  try {
+    const mfTypePath = retrieveMfTypesPath(tsConfig, remoteOptions);
+    const thirdPartyExtractor = new import_third_party_dts_extractor.ThirdPartyExtractor((0, import_path2.resolve)(mfTypePath, "node_modules"), remoteOptions.context);
+    const execPromise = import_util.default.promisify(import_child_process.exec);
+    const cmd = `npx ${remoteOptions.compilerInstance} --project ${tempTsConfigJsonPath}`;
+    try {
+      yield execPromise(cmd);
+    } catch (err) {
+      throw new Error(`compile TS failed, the original command is '${cmd}'`);
+    }
+    const mapExposeToEntry = Object.fromEntries(Object.entries(mapComponentsToExpose).map(([exposed, filename]) => {
+      const normalizedFileName = (0, import_path2.normalize)(filename);
+      let relativeFileName = "";
+      if ((0, import_path2.isAbsolute)(normalizedFileName)) {
+        relativeFileName = (0, import_path2.relative)(tsConfig.compilerOptions.rootDir, normalizedFileName);
+      } else {
+        relativeFileName = (0, import_path2.relative)(tsConfig.compilerOptions.rootDir, (0, import_path2.resolve)(remoteOptions.context, normalizedFileName));
       }
+      return [
+        removeExt(relativeFileName),
+        exposed
+      ];
+    }));
+    const cb = remoteOptions.extractThirdParty ? thirdPartyExtractor.collectPkgs.bind(thirdPartyExtractor) : () => void 0;
+    yield processTypesFile({
+      outDir: compilerOptions.outDir,
+      filePath: compilerOptions.outDir,
+      rootDir: compilerOptions.rootDir,
+      mfTypePath,
+      cb,
+      mapExposeToEntry
+    });
+    if (remoteOptions.extractThirdParty) {
+      yield thirdPartyExtractor.copyDts();
     }
-    cb(text);
-  };
-  return host;
-}, "createHost");
-var createVueTscProgram = /* @__PURE__ */ __name((programOptions) => {
-  const vueTypescript = require("vue-tsc");
-  return vueTypescript.createProgram(programOptions);
-}, "createVueTscProgram");
-var createProgram = /* @__PURE__ */ __name((remoteOptions, programOptions) => {
-  switch (remoteOptions.compilerInstance) {
-    case "vue-tsc":
-      return createVueTscProgram(programOptions);
-    case "tsc":
-    default:
-      return import_typescript2.default.createProgram(programOptions);
-  }
-}, "createProgram");
-var compileTs = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions) => {
-  const mfTypePath = retrieveMfTypesPath(tsConfig, remoteOptions);
-  const thirdPartyExtractor = new import_third_party_dts_extractor.ThirdPartyExtractor((0, import_path2.resolve)(mfTypePath, "node_modules"), remoteOptions.context);
-  const cb = remoteOptions.extractThirdParty ? thirdPartyExtractor.collectPkgs.bind(thirdPartyExtractor) : () => void 0;
-  const tsHost = createHost(mapComponentsToExpose, tsConfig, remoteOptions, cb);
-  const filesToCompile = [
-    ...Object.values(mapComponentsToExpose),
-    ...remoteOptions.additionalFilesToCompile
-  ];
-  const programOptions = {
-    rootNames: filesToCompile,
-    host: tsHost,
-    options: tsConfig
-  };
-  const tsProgram = createProgram(remoteOptions, programOptions);
-  const { diagnostics = [] } = tsProgram.emit();
-  diagnostics.forEach(reportCompileDiagnostic);
-  if (remoteOptions.extractThirdParty) {
-    thirdPartyExtractor.copyDts();
+    yield (0, import_promises.rm)(tempTsConfigJsonPath);
+  } catch (err) {
+    if (isDebugMode()) {
+      console.log("tsconfig: ", JSON.stringify(tsConfig, null, 2));
+    }
+    throw err;
   }
-}, "compileTs");
+}), "compileTs");
 
 // packages/dts-plugin/src/server/message/Message.ts
 var _Message = class _Message {
@@ -391,7 +463,7 @@ __name(_FetchTypesAPI, "FetchTypesAPI");
 var FetchTypesAPI = _FetchTypesAPI;
 
 // packages/dts-plugin/src/server/utils/index.ts
-var import_sdk2 = require("@module-federation/sdk");
+var import_sdk3 = require("@module-federation/sdk");
 
 // packages/dts-plugin/src/server/utils/logTransform.ts
 var import_chalk = __toESM(require("chalk"));
@@ -430,7 +502,7 @@ __name(_BrokerExitLog, "BrokerExitLog");
 var BrokerExitLog = _BrokerExitLog;
 
 // packages/dts-plugin/src/server/utils/log.ts
-var import_sdk = require("@module-federation/sdk");
+var import_sdk2 = require("@module-federation/sdk");
 var log4js = __toESM(require("log4js"));
 var import_chalk2 = __toESM(require("chalk"));
 
@@ -485,7 +557,7 @@ __name(error, "error");
 // packages/dts-plugin/src/server/utils/index.ts
 function getIdentifier(options) {
   const { ip, name } = options;
-  return `mf ${import_sdk2.SEPARATOR}${name}${ip ? `${import_sdk2.SEPARATOR}${ip}` : ""}`;
+  return `mf ${import_sdk3.SEPARATOR}${name}${ip ? `${import_sdk3.SEPARATOR}${ip}` : ""}`;
 }
 __name(getIdentifier, "getIdentifier");
 
@@ -583,7 +655,7 @@ var Publisher = _Publisher;
 var import_isomorphic_ws2 = __toESM(require("isomorphic-ws"));
 
 // packages/dts-plugin/src/core/configurations/hostPlugin.ts
-var import_sdk3 = require("@module-federation/sdk");
+var import_sdk4 = require("@module-federation/sdk");
 var import_managers2 = require("@module-federation/managers");
 var defaultOptions2 = {
   typesFolder: "@mf-types",
@@ -610,10 +682,10 @@ var buildApiTypeUrl = /* @__PURE__ */ __name((zipUrl) => {
 var retrieveRemoteInfo = /* @__PURE__ */ __name((options) => {
   const { hostOptions, remoteAlias, remote } = options;
   let decodedRemote = remote;
-  if (decodedRemote.startsWith(import_sdk3.ENCODE_NAME_PREFIX)) {
-    decodedRemote = (0, import_sdk3.decodeName)(decodedRemote, import_sdk3.ENCODE_NAME_PREFIX);
+  if (decodedRemote.startsWith(import_sdk4.ENCODE_NAME_PREFIX)) {
+    decodedRemote = (0, import_sdk4.decodeName)(decodedRemote, import_sdk4.ENCODE_NAME_PREFIX);
   }
-  const parsedInfo = (0, import_sdk3.parseEntry)(decodedRemote, void 0, "@");
+  const parsedInfo = (0, import_sdk4.parseEntry)(decodedRemote, void 0, "@");
   const url = "entry" in parsedInfo ? parsedInfo.entry : parsedInfo.name === decodedRemote ? decodedRemote : "";
   const zipUrl = url ? buildZipUrl(hostOptions, url) : "";
   return {
@@ -750,7 +822,7 @@ __name(wrapRpc, "wrapRpc");
 // packages/dts-plugin/src/core/rpc/rpc-worker.ts
 var child_process = __toESM(require("child_process"));
 var process3 = __toESM(require("process"));
-var import_crypto = require("crypto");
+var import_crypto2 = require("crypto");
 var FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
 function createRpcWorker(modulePath, data, memoryLimit, once) {
   const options = {
@@ -771,7 +843,7 @@ function createRpcWorker(modulePath, data, memoryLimit, once) {
     ];
   }
   let childProcess, remoteMethod;
-  const id = (0, import_crypto.randomUUID)();
+  const id = (0, import_crypto2.randomUUID)();
   const worker = {
     connect(...args) {
       if (childProcess && !childProcess.connected) {
@@ -1436,7 +1508,7 @@ __publicField(_Broker, "DEFAULT_WAITING_TIME", 1.5 * 60 * 60 * 1e3);
 var Broker = _Broker;
 
 // packages/dts-plugin/src/server/createKoaServer.ts
-var import_fs_extra = __toESM(require("fs-extra"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
 var import_koa = __toESM(require("koa"));
 
 // packages/dts-plugin/src/core/lib/archiveHandler.ts
@@ -1467,7 +1539,7 @@ var downloadTypesArchive = /* @__PURE__ */ __name((hostOptions) => {
         }).catch(downloadErrorLogger(destinationFolder, url));
         try {
           if (hostOptions.deleteTypesFolder) {
-            yield (0, import_promises.rm)(destinationPath, {
+            yield (0, import_promises2.rm)(destinationPath, {
               recursive: true,
               force: true
             });
@@ -1577,12 +1649,12 @@ var DTSManager = (_a2 = class {
         if (!Object.keys(mapComponentsToExpose).length) {
           return;
         }
-        this.extractRemoteTypes({
+        yield this.extractRemoteTypes({
           remoteOptions,
           tsConfig,
           mapComponentsToExpose
         });
-        compileTs(mapComponentsToExpose, tsConfig, remoteOptions);
+        yield compileTs(mapComponentsToExpose, tsConfig, remoteOptions);
         yield createTypesArchive(tsConfig, remoteOptions);
         let apiTypesPath = "";
         if (remoteOptions.generateAPITypes) {
@@ -1592,7 +1664,7 @@ var DTSManager = (_a2 = class {
         }
         try {
           if (remoteOptions.deleteTypesFolder) {
-            yield (0, import_promises2.rm)(retrieveMfTypesPath(tsConfig, remoteOptions), {
+            yield (0, import_promises3.rm)(retrieveMfTypesPath(tsConfig, remoteOptions), {
               recursive: true,
               force: true
             });
@@ -1602,10 +1674,10 @@ var DTSManager = (_a2 = class {
             console.error(err);
           }
         }
-        console.log(import_ansi_colors2.default.green("Federated types created correctly"));
+        console.log(import_ansi_colors.default.green("Federated types created correctly"));
       } catch (error2) {
         if (((_a3 = this.options.remote) == null ? void 0 : _a3.abortOnError) === false) {
-          console.error(import_ansi_colors2.default.red(`Unable to compile federated types, ${error2}`));
+          console.error(import_ansi_colors.default.red(`Unable to compile federated types, ${error2}`));
         } else {
           throw error2;
         }
@@ -1615,7 +1687,7 @@ var DTSManager = (_a2 = class {
   requestRemoteManifest(remoteInfo) {
     return __async(this, null, function* () {
       try {
-        if (!remoteInfo.url.includes(import_sdk4.MANIFEST_EXT)) {
+        if (!remoteInfo.url.includes(import_sdk5.MANIFEST_EXT)) {
           return remoteInfo;
         }
         const url = remoteInfo.url;
@@ -1642,7 +1714,7 @@ var DTSManager = (_a2 = class {
           }
         }
         if (publicPath === "auto") {
-          publicPath = (0, import_sdk4.inferAutoPublicPath)(remoteInfo.url);
+          publicPath = (0, import_sdk5.inferAutoPublicPath)(remoteInfo.url);
         }
         remoteInfo.zipUrl = new URL(import_path4.default.join(addProtocol(publicPath), manifestJson.metaData.types.zip)).href;
         if (!manifestJson.metaData.types.api) {
@@ -1777,7 +1849,7 @@ var DTSManager = (_a2 = class {
           })));
           this.consumeAPITypes(hostOptions);
         }
-        console.log(import_ansi_colors2.default.green("Federated types extraction completed"));
+        console.log(import_ansi_colors.default.green("Federated types extraction completed"));
       } catch (err) {
         if (((_a3 = this.options.host) == null ? void 0 : _a3.abortOnError) === false) {
           fileLog(`Unable to consume federated types, ${err}`, "consumeTypes", "error");
@@ -1798,7 +1870,7 @@ var DTSManager = (_a2 = class {
           if (!this.options.remote) {
             return;
           }
-          this.generateTypes();
+          yield this.generateTypes();
         } else {
           const { remoteAliasMap } = this;
           if (!this.options.host) {