@module-federation/dts-plugin 0.2.5 → 0.2.7

package/dist/esm/{chunk-CRKFI32N.js → chunk-ZLQBXHXA.js}

@@ -26,10 +26,10 @@ import {
 } from "./chunk-MQRIERJP.js";
 
 // packages/dts-plugin/src/core/configurations/remotePlugin.ts
-import { existsSync } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve3, extname } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join3, resolve as resolve3, extname as extname2 } from "path";
 import { utils as utils2 } from "@module-federation/managers";
-import typescript2 from "typescript";
+import typescript from "typescript";
 
 // packages/dts-plugin/src/core/lib/utils.ts
 import fs3 from "fs";
@@ -37,12 +37,12 @@ import path3 from "path";
 import axios from "axios";
 import http from "http";
 import https from "https";
-import ansiColors3 from "ansi-colors";
+import ansiColors2 from "ansi-colors";
 
 // packages/dts-plugin/src/core/lib/DTSManager.ts
-import ansiColors2 from "ansi-colors";
+import ansiColors from "ansi-colors";
 import path2 from "path";
-import { rm as rm2 } from "fs/promises";
+import { rm as rm3 } from "fs/promises";
 import fs2 from "fs";
 import { MANIFEST_EXT, inferAutoPublicPath } from "@module-federation/sdk";
 import cloneDeepWith from "lodash.clonedeepwith";
@@ -51,84 +51,116 @@ import { ThirdPartyExtractor as ThirdPartyExtractor2 } from "@module-federation/
 // packages/dts-plugin/src/core/lib/archiveHandler.ts
 import AdmZip from "adm-zip";
 import { resolve as resolve2, join as join2 } from "path";
-import { rm } from "fs/promises";
+import { rm as rm2 } from "fs/promises";
 
 // packages/dts-plugin/src/core/lib/typeScriptCompiler.ts
-import ansiColors from "ansi-colors";
-import { dirname, join, normalize, relative, resolve, sep } from "path";
-import typescript from "typescript";
+import { ensureDirSync, writeFileSync, existsSync } from "fs-extra";
+import { stat, readdir, writeFile, rm, readFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { dirname, join, normalize, relative, resolve, sep, extname, isAbsolute } from "path";
 import { ThirdPartyExtractor } from "@module-federation/third-party-dts-extractor";
+import { exec } from "child_process";
+import util from "util";
+import { TEMP_DIR } from "@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(ansiColors.red(`TS Error ${diagnostic.code}':' ${typescript.flattenDiagnosticMessageText(diagnostic.messageText, typescript.sys.newLine)}`));
-  console.error(ansiColors.red(`         at ${diagnostic.file.fileName}:${line + 1} typescript.sys.newLine`));
-}, "reportCompileDiagnostic");
-var retrieveMfTypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.outDir.replace(remoteOptions.compiledTypesFolder, "")), "retrieveMfTypesPath");
-var retrieveOriginalOutDir = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.outDir.replace(remoteOptions.compiledTypesFolder, "").replace(remoteOptions.typesFolder, "")), "retrieveOriginalOutDir");
+var retrieveMfTypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "")), "retrieveMfTypesPath");
+var retrieveOriginalOutDir = /* @__PURE__ */ __name((tsConfig, remoteOptions) => normalize(tsConfig.compilerOptions.outDir.replace(remoteOptions.compiledTypesFolder, "").replace(remoteOptions.typesFolder, "")), "retrieveOriginalOutDir");
 var retrieveMfAPITypesPath = /* @__PURE__ */ __name((tsConfig, remoteOptions) => join(retrieveOriginalOutDir(tsConfig, remoteOptions), `${remoteOptions.typesFolder}.d.ts`), "retrieveMfAPITypesPath");
-var createHost = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions, cb) => {
-  const host = typescript.createCompilerHost(tsConfig);
-  const originalWriteFile = host.writeFile;
-  const mapExposeToEntry = Object.fromEntries(Object.entries(mapComponentsToExpose).map(([exposed, filename]) => [
-    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[normalize(sourceFile.fileName)];
-      if (sourceEntry === ".") {
-        sourceEntry = "index";
-      }
-      if (sourceEntry) {
-        const mfeTypeEntry = join(mfTypePath, `${sourceEntry}${DEFINITION_FILE_EXTENSION}`);
-        const mfeTypeEntryDirectory = dirname(mfeTypeEntry);
-        const relativePathToOutput = relative(mfeTypeEntryDirectory, filepath).replace(DEFINITION_FILE_EXTENSION, "").replace(STARTS_WITH_SLASH, "").split(sep).join("/");
-        originalWriteFile(mfeTypeEntry, `export * from './${relativePathToOutput}';
-export { default } from './${relativePathToOutput}';`, writeOrderByteMark);
+function writeTempTsConfig(tsConfig, context) {
+  const tempTsConfigJsonPath = resolve(context, "node_modules", TEMP_DIR, `tsconfig.${randomUUID()}.json`);
+  ensureDirSync(dirname(tempTsConfigJsonPath));
+  writeFileSync(tempTsConfigJsonPath, JSON.stringify(tsConfig, null, 2));
+  return tempTsConfigJsonPath;
+}
+__name(writeTempTsConfig, "writeTempTsConfig");
+var removeExt = /* @__PURE__ */ __name((f) => {
+  const ext = extname(f);
+  const regexPattern = new RegExp(`\\${ext}$`);
+  return f.replace(regexPattern, "");
+}, "removeExt");
+function getExposeKey(options) {
+  const { filePath, rootDir, outDir, mapExposeToEntry } = options;
+  const relativeFilePath = removeExt(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 (!existsSync(filePath)) {
+    return;
+  }
+  const stats = yield stat(filePath);
+  if (stats.isDirectory()) {
+    const files = yield readdir(filePath);
+    yield Promise.all(files.map((file) => processTypesFile(__spreadProps(__spreadValues({}, options), {
+      filePath: 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 = join(mfTypePath, `${sourceEntry}${DEFINITION_FILE_EXTENSION}`);
+      const mfeTypeEntryDirectory = dirname(mfeTypeEntry);
+      const relativePathToOutput = relative(mfeTypeEntryDirectory, filePath).replace(DEFINITION_FILE_EXTENSION, "").replace(STARTS_WITH_SLASH, "").split(sep).join("/");
+      yield writeFile(mfeTypeEntry, `export * from './${relativePathToOutput}';
+export { default } from './${relativePathToOutput}';`);
+    }
+    const content = yield 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 ThirdPartyExtractor(resolve(mfTypePath, "node_modules"), remoteOptions.context);
+    const execPromise = util.promisify(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 = normalize(filename);
+      let relativeFileName = "";
+      if (isAbsolute(normalizedFileName)) {
+        relativeFileName = relative(tsConfig.compilerOptions.rootDir, normalizedFileName);
+      } else {
+        relativeFileName = relative(tsConfig.compilerOptions.rootDir, 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 typescript.createProgram(programOptions);
-  }
-}, "createProgram");
-var compileTs = /* @__PURE__ */ __name((mapComponentsToExpose, tsConfig, remoteOptions) => {
-  const mfTypePath = retrieveMfTypesPath(tsConfig, remoteOptions);
-  const thirdPartyExtractor = new ThirdPartyExtractor(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 rm(tempTsConfigJsonPath);
+  } catch (err) {
+    throw err;
   }
-}, "compileTs");
+}), "compileTs");
 
 // packages/dts-plugin/src/server/message/API/API.ts
 var APIKind;
@@ -1435,7 +1467,7 @@ var downloadTypesArchive = /* @__PURE__ */ __name((hostOptions) => {
         }).catch(downloadErrorLogger(destinationFolder, url));
         try {
           if (hostOptions.deleteTypesFolder) {
-            yield rm(destinationPath, {
+            yield rm2(destinationPath, {
               recursive: true,
               force: true
             });
@@ -1620,7 +1652,7 @@ var DTSManager = (_a = class {
           tsConfig,
           mapComponentsToExpose
         });
-        compileTs(mapComponentsToExpose, tsConfig, remoteOptions);
+        yield compileTs(mapComponentsToExpose, tsConfig, remoteOptions);
         yield createTypesArchive(tsConfig, remoteOptions);
         let apiTypesPath = "";
         if (remoteOptions.generateAPITypes) {
@@ -1630,7 +1662,7 @@ var DTSManager = (_a = class {
         }
         try {
           if (remoteOptions.deleteTypesFolder) {
-            yield rm2(retrieveMfTypesPath(tsConfig, remoteOptions), {
+            yield rm3(retrieveMfTypesPath(tsConfig, remoteOptions), {
               recursive: true,
               force: true
             });
@@ -1640,10 +1672,10 @@ var DTSManager = (_a = class {
             console.error(err);
           }
         }
-        console.log(ansiColors2.green("Federated types created correctly"));
+        console.log(ansiColors.green("Federated types created correctly"));
       } catch (error2) {
         if (((_a3 = this.options.remote) == null ? void 0 : _a3.abortOnError) === false) {
-          console.error(ansiColors2.red(`Unable to compile federated types, ${error2}`));
+          console.error(ansiColors.red(`Unable to compile federated types, ${error2}`));
         } else {
           throw error2;
         }
@@ -1815,7 +1847,7 @@ var DTSManager = (_a = class {
           })));
           this.consumeAPITypes(hostOptions);
         }
-        console.log(ansiColors2.green("Federated types extraction completed"));
+        console.log(ansiColors.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");
@@ -1836,7 +1868,7 @@ var DTSManager = (_a = class {
           if (!this.options.remote) {
             return;
           }
-          this.generateTypes();
+          yield this.generateTypes();
         } else {
           const { remoteAliasMap } = this;
           if (!this.options.host) {
@@ -1928,7 +1960,7 @@ function retrieveTypesAssetsInfo(options) {
       apiFileName: path3.basename(apiTypesPath)
     };
   } catch (err) {
-    console.error(ansiColors3.red(`Unable to compile federated types, ${err}`));
+    console.error(ansiColors2.red(`Unable to compile federated types, ${err}`));
     return {
       apiTypesPath: "",
       zipTypesPath: "",
@@ -1994,20 +2026,56 @@ var defaultOptions2 = {
   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) => dirname2(file)).reduce((commonPath, fileDir) => {
+      while (!fileDir.startsWith(commonPath)) {
+        commonPath = dirname2(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 = resolve3(context, tsConfigPath);
-  const readResult = typescript2.readConfigFile(resolvedTsConfigPath, typescript2.sys.readFile);
+  const readResult = typescript.readConfigFile(resolvedTsConfigPath, typescript.sys.readFile);
   if (readResult.error) {
     throw new Error(readResult.error.messageText.toString());
   }
-  const configContent = typescript2.parseJsonConfigFileContent(readResult.config, typescript2.sys, dirname2(resolvedTsConfigPath));
+  const rawTsConfigJson = readResult.config;
+  const configContent = typescript.parseJsonConfigFileContent(rawTsConfigJson, typescript.sys, dirname2(resolvedTsConfigPath));
+  const rootDir = getEffectiveRootDir(configContent);
   const outDir = resolve3(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 = resolve3(context, extendsPath);
+  }
+  return rawTsConfigJson;
 }, "readTsConfig");
 var TS_EXTENSIONS = [
   "ts",
@@ -2016,12 +2084,12 @@ var TS_EXTENSIONS = [
   "svelte"
 ];
 var resolveWithExtension = /* @__PURE__ */ __name((exposedPath, context) => {
-  if (extname(exposedPath)) {
+  if (extname2(exposedPath)) {
     return resolve3(context, exposedPath);
   }
   for (const extension of TS_EXTENSIONS) {
     const exposedPathWithExtension = resolve3(context, `${exposedPath}.${extension}`);
-    if (existsSync(exposedPathWithExtension)) {
+    if (existsSync2(exposedPathWithExtension)) {
       return exposedPathWithExtension;
     }
   }
@@ -2045,7 +2113,7 @@ var retrieveRemoteConfig = /* @__PURE__ */ __name((options) => {
   validateOptions(options);
   const remoteOptions = __spreadValues(__spreadValues({}, defaultOptions2), options);
   const mapComponentsToExpose = resolveExposes(remoteOptions);
-  const tsConfig = readTsConfig(remoteOptions);
+  const tsConfig = readTsConfig(remoteOptions, mapComponentsToExpose);
   return {
     tsConfig,
     mapComponentsToExpose,
@@ -2231,7 +2299,7 @@ __name(wrapRpc, "wrapRpc");
 // packages/dts-plugin/src/core/rpc/rpc-worker.ts
 import * as child_process from "child_process";
 import * as process3 from "process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
 function createRpcWorker(modulePath, data, memoryLimit, once) {
   const options = {
@@ -2252,7 +2320,7 @@ function createRpcWorker(modulePath, data, memoryLimit, once) {
     ];
   }
   let childProcess, remoteMethod;
-  const id = randomUUID();
+  const id = randomUUID2();
   const worker = {
     connect(...args) {
       if (childProcess && !childProcess.connected) {

package/dist/esm/core.js

@@ -14,7 +14,7 @@ import {
   retrieveTypesZipPath,
   rpc_exports,
   validateOptions
-} from "./chunk-CRKFI32N.js";
+} from "./chunk-ZLQBXHXA.js";
 import {
   HOST_API_TYPES_FILE_NAME,
   REMOTE_ALIAS_IDENTIFIER,

package/dist/esm/fork-dev-worker.js

@@ -9,7 +9,7 @@ import {
   retrieveRemoteConfig,
   retrieveTypesZipPath,
   rpc_exports
-} from "./chunk-CRKFI32N.js";
+} from "./chunk-ZLQBXHXA.js";
 import {
   getIpFromEntry
 } from "./chunk-G7ONFBMA.js";

package/dist/esm/fork-generate-dts.js

@@ -2,7 +2,7 @@ import {
   RpcGMCallTypes,
   exposeRpc,
   generateTypes
-} from "./chunk-CRKFI32N.js";
+} from "./chunk-ZLQBXHXA.js";
 import {
   __async,
   __name

package/dist/esm/index.js

@@ -7,7 +7,7 @@ import {
   retrieveTypesAssetsInfo,
   rpc_exports,
   validateOptions
-} from "./chunk-CRKFI32N.js";
+} from "./chunk-ZLQBXHXA.js";
 import {
   WEB_CLIENT_OPTIONS_IDENTIFIER,
   __async,
@@ -89,7 +89,7 @@ function createDevWorker(options) {
 __name(createDevWorker, "createDevWorker");
 
 // packages/dts-plugin/src/plugins/DevPlugin.ts
-import { normalizeOptions } from "@module-federation/sdk";
+import { normalizeOptions, TEMP_DIR as BasicTempDir } from "@module-federation/sdk";
 import path3 from "path";
 
 // packages/dts-plugin/src/plugins/utils.ts
@@ -182,7 +182,7 @@ var _DevPlugin = class _DevPlugin {
       this._options.runtimePlugins.push(path3.resolve(__dirname, "dynamic-remote-type-hints-plugin.js"));
     }
     if (!normalizedDev.disableLiveReload) {
-      const TEMP_DIR = path3.join(`${process.cwd()}/node_modules`, `.federation`);
+      const TEMP_DIR = path3.join(`${process.cwd()}/node_modules`, BasicTempDir);
       const filepath = path3.join(TEMP_DIR, `live-reload.js`);
       _DevPlugin.ensureLiveReloadEntry({
         name
@@ -341,10 +341,9 @@ var _GenerateTypesPlugin = class _GenerateTypesPlugin {
           yield generateTypesFn(finalOptions);
           const config = finalOptions.remote.moduleFederationConfig;
           let zipPrefix = "";
-          const isManifestObject = typeof config.manifest === "object";
-          if (isManifestObject && config.manifest.filePath) {
+          if (typeof config.manifest === "object" && config.manifest.filePath) {
             zipPrefix = config.manifest.filePath;
-          } else if (isManifestObject && config.manifest.fileName) {
+          } else if (typeof config.manifest === "object" && config.manifest.fileName) {
             zipPrefix = path4.dirname(config.manifest.fileName);
           } else if (config.filename) {
             zipPrefix = path4.dirname(config.filename);

package/dist/esm/start-broker.js

@@ -1,7 +1,7 @@
 import {
   Broker,
   fileLog
-} from "./chunk-CRKFI32N.js";
+} from "./chunk-ZLQBXHXA.js";
 import {
   __async,
   __name