vite-plugin-dts 3.7.2 → 3.8.0

package/dist/index.mjs

@@ -16,6 +16,7 @@ import { createProgram } from 'vue-tsc';
 import debug from 'debug';
 import { cyan, yellow, green } from 'kolorist';
 import { ExtractorConfig, Extractor } from '@microsoft/api-extractor';
+import MagicString from 'magic-string';
 
 const windowsSlashRE = /\\+/g;
 function slash(p) {
@@ -36,7 +37,7 @@ function isRegExp(value) {
 function isPromise(value) {
   return !!value && (typeof value === "function" || typeof value === "object") && typeof value.then === "function";
 }
-async function wrapPromise(maybePromise) {
+async function unwrapPromise(maybePromise) {
   return isPromise(maybePromise) ? await maybePromise : maybePromise;
 }
 function ensureAbsolute(path, root) {
@@ -413,46 +414,13 @@ function normalizeGlob(path) {
   }
   return path;
 }
-const globalDynamicTypeRE = /import\(['"][^;\n]+?['"]\)\.\w+[.()[\]<>,;\n\s]/g;
-const dynamicTypeRE = /import\(['"](.+)['"]\)\.(.+)([.()[\]<>,;\n\s])/;
-const importTypesRE = /import\s?(?:type)?\s?\{(.+)\}\s?from\s?['"].+['"]/;
-function transformDynamicImport(content) {
-  const importMap = /* @__PURE__ */ new Map();
-  const defaultMap = /* @__PURE__ */ new Map();
-  let defaultCount = 1;
-  content = content.replace(globalDynamicTypeRE, (str) => {
-    const matchResult = str.match(dynamicTypeRE);
-    const libName = matchResult[1];
-    const importSet = importMap.get(libName) ?? importMap.set(libName, /* @__PURE__ */ new Set()).get(libName);
-    let usedType = matchResult[2];
-    if (usedType === "default") {
-      usedType = defaultMap.get(libName) ?? defaultMap.set(libName, `__DTS_${defaultCount++}__`).get(libName);
-      importSet.add(`default as ${usedType}`);
-    } else {
-      importSet.add(usedType);
-    }
-    return usedType + matchResult[3];
-  });
-  importMap.forEach((importSet, libName) => {
-    const importReg = new RegExp(
-      `import\\s?(?:type)?\\s?\\{[^;\\n]+\\}\\s?from\\s?['"]${libName}['"]`,
-      "g"
-    );
-    const matchResult = content.match(importReg);
-    if (matchResult?.[0]) {
-      matchResult[0].match(importTypesRE)[1].trim().split(",").forEach((type) => {
-        type && importSet.add(type.trim());
-      });
-      content = content.replace(
-        matchResult[0],
-        `import { ${Array.from(importSet).join(", ")} } from '${libName}'`
-      );
-    } else {
-      content = `import { ${Array.from(importSet).join(", ")} } from '${libName}';
-` + content;
+function walkSourceFile(sourceFile, callback) {
+  function walkNode(node, parent, callback2) {
+    if (callback2(node, parent) !== false) {
+      node.forEachChild((child) => walkNode(child, node, callback2));
     }
-  });
-  return content;
+  }
+  sourceFile.forEachChild((child) => walkNode(child, sourceFile, callback));
 }
 function isAliasMatch(alias, importer) {
   if (isRegExp(alias.find))
@@ -463,54 +431,132 @@ function isAliasMatch(alias, importer) {
     return true;
   return importer.indexOf(alias.find) === 0 && (alias.find.endsWith("/") || importer.substring(alias.find.length)[0] === "/");
 }
-function ensureStartWithDot(path) {
-  return path.startsWith(".") ? path : `./${path}`;
-}
-const globalImportRE = /(?:(?:import|export)\s?(?:type)?\s?(?:(?:\{[^;\n]+\})|(?:[^;\n]+))\s?from\s?['"][^;\n]+['"])|(?:import\(['"][^;\n]+?['"]\))/g;
-const staticImportRE = /(?:import|export)\s?(?:type)?\s?\{?.+\}?\s?from\s?['"](.+)['"]/;
-const dynamicImportRE = /import\(['"]([^;\n]+?)['"]\)/;
-const simpleStaticImportRE = /((?:import|export).+from\s?)['"](.+)['"]/;
-const simpleDynamicImportRE = /(import\()['"](.+)['"]\)/;
-function transformAliasImport(filePath, content, aliases, exclude = []) {
-  if (!aliases?.length)
-    return content;
-  return content.replace(globalImportRE, (str) => {
-    let matchResult = str.match(staticImportRE);
-    let isDynamic = false;
-    if (!matchResult) {
-      matchResult = str.match(dynamicImportRE);
-      isDynamic = true;
+function transformAlias(importer, dir, aliases, aliasesExclude) {
+  if (aliases.length && !aliasesExclude.some((e) => isRegExp(e) ? e.test(importer) : String(e) === importer)) {
+    const matchedAlias = aliases.find((alias) => isAliasMatch(alias, importer));
+    if (matchedAlias) {
+      const replacement = isAbsolute(matchedAlias.replacement) ? normalizePath(relative(dir, matchedAlias.replacement)) : normalizePath(matchedAlias.replacement);
+      const endsWithSlash = typeof matchedAlias.find === "string" ? matchedAlias.find.endsWith("/") : importer.match(matchedAlias.find)[0].endsWith("/");
+      const truthPath = importer.replace(
+        matchedAlias.find,
+        replacement + (endsWithSlash ? "/" : "")
+      );
+      const normalizedPath = normalizePath(relative(dir, resolve$1(dir, truthPath)));
+      return normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
     }
-    if (matchResult?.[1]) {
-      const matchedAlias = aliases.find((alias) => isAliasMatch(alias, matchResult[1]));
-      if (matchedAlias) {
-        if (exclude.some((e) => isRegExp(e) ? e.test(matchResult[1]) : String(e) === matchResult[1])) {
-          return str;
-        }
-        const dir = dirname(filePath);
-        const replacement = isAbsolute(matchedAlias.replacement) ? normalizePath(relative(dir, matchedAlias.replacement)) : normalizePath(matchedAlias.replacement);
-        const endSlash = typeof matchedAlias.find === "string" ? matchedAlias.find.endsWith("/") : matchResult[1].match(matchedAlias.find)[0].endsWith("/");
-        const truthPath = matchResult[1].replace(
-          matchedAlias.find,
-          replacement + (endSlash ? "/" : "")
-        );
-        const normalizedPath = normalizePath(relative(dir, resolve$1(dir, truthPath)));
-        return str.replace(
-          isDynamic ? simpleDynamicImportRE : simpleStaticImportRE,
-          `$1'${ensureStartWithDot(normalizedPath)}'${isDynamic ? ")" : ""}`
+  }
+  return importer;
+}
+function transformCode(options) {
+  const s = new MagicString(options.content);
+  const ast = ts.createSourceFile("a.ts", options.content, ts.ScriptTarget.Latest);
+  const dir = dirname(options.filePath);
+  const importMap = /* @__PURE__ */ new Map();
+  const usedDefault = /* @__PURE__ */ new Map();
+  const declareModules = [];
+  let indexCount = 0;
+  walkSourceFile(ast, (node, parent) => {
+    if (ts.isImportDeclaration(node)) {
+      if (!node.importClause) {
+        options.clearPureImport && s.remove(node.pos, node.end);
+      } else if (ts.isStringLiteral(node.moduleSpecifier) && (node.importClause.name || node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings))) {
+        const libName = transformAlias(
+          node.moduleSpecifier.text,
+          dir,
+          options.aliases,
+          options.aliasesExclude
         );
+        const importSet = importMap.get(libName) ?? importMap.set(libName, /* @__PURE__ */ new Set()).get(libName);
+        if (node.importClause.name && !usedDefault.has(libName)) {
+          const usedType = node.importClause.name.escapedText;
+          usedDefault.set(libName, usedType);
+          importSet.add(`default as ${usedType}`);
+        }
+        if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+          node.importClause.namedBindings.elements.forEach((element) => {
+            importSet.add(element.name.escapedText);
+          });
+        }
+        s.remove(node.pos, node.end);
       }
+      return false;
+    }
+    if (ts.isImportTypeNode(node) && node.qualifier && ts.isLiteralTypeNode(node.argument) && ts.isIdentifier(node.qualifier) && ts.isStringLiteral(node.argument.literal)) {
+      const libName = transformAlias(
+        node.argument.literal.text,
+        dir,
+        options.aliases,
+        options.aliasesExclude
+      );
+      if (!options.staticImport) {
+        s.update(node.argument.literal.pos, node.argument.literal.end, `'${libName}'`);
+        return false;
+      }
+      const importSet = importMap.get(libName) ?? importMap.set(libName, /* @__PURE__ */ new Set()).get(libName);
+      let usedType = node.qualifier.escapedText;
+      if (usedType === "default") {
+        usedType = usedDefault.get(libName) ?? usedDefault.set(libName, `__DTS_DEFAULT_${indexCount++}__`).get(libName);
+        importSet.add(`default as ${usedType}`);
+        s.update(node.qualifier.pos, node.qualifier.end, usedType);
+      } else {
+        importSet.add(usedType);
+      }
+      if (ts.isImportTypeNode(parent) && parent.typeArguments && parent.typeArguments[0] === node) {
+        s.remove(node.pos, node.argument.end + 2);
+      } else {
+        s.update(node.pos, node.argument.end + 2, " ");
+      }
+      return !!node.typeArguments;
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword && ts.isStringLiteral(node.arguments[0])) {
+      const libName = transformAlias(
+        node.arguments[0].text,
+        dir,
+        options.aliases,
+        options.aliasesExclude
+      );
+      s.update(node.arguments[0].pos, node.arguments[0].end, `'${libName}'`);
+      return false;
+    }
+    if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+      const libName = transformAlias(
+        node.moduleSpecifier.text,
+        dir,
+        options.aliases,
+        options.aliasesExclude
+      );
+      s.update(node.moduleSpecifier.pos, node.moduleSpecifier.end, ` '${libName}'`);
+      return false;
+    }
+    if (ts.isModuleDeclaration(node)) {
+      declareModules.push(s.slice(node.pos, node.end + 1));
     }
-    return str;
   });
+  importMap.forEach((importSet, libName) => {
+    s.prepend(`import { ${Array.from(importSet).join(", ")} } from '${libName}';
+`);
+  });
+  return {
+    content: s.toString(),
+    declareModules
+  };
 }
-const pureImportRE = /import\s?['"][^;\n]+?['"];?\n?/g;
-function removePureImport(content) {
-  return content.replace(pureImportRE, "");
-}
-const asDefaultRE = /export\s*\{.*\w+\s*\bas\s+default\b.*\}\s*from\s*['"].+['"]/;
 function hasExportDefault(content) {
-  return content.includes("export default") || asDefaultRE.test(content);
+  const ast = ts.createSourceFile("a.ts", content, ts.ScriptTarget.Latest);
+  let has = false;
+  walkSourceFile(ast, (node) => {
+    if (ts.isExportAssignment(node)) {
+      has = true;
+    } else if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements) {
+        if (element.name.escapedText === "default") {
+          has = true;
+        }
+      }
+    }
+    return false;
+  });
+  return has;
 }
 
 const jsRE = /\.(m|c)?jsx?$/;
@@ -521,7 +567,8 @@ const mtjsRE = /\.m(t|j)sx?$/;
 const ctjsRE = /\.c(t|j)sx?$/;
 const fullRelativeRE = /^\.\.?\//;
 const defaultIndex = "index.d.ts";
-const logPrefix = cyan("[vite:dts]");
+const pluginName = "vite:dts";
+const logPrefix = cyan(`[${pluginName}]`);
 const bundleDebug = debug("vite-plugin-dts:bundle");
 const fixedCompilerOptions = {
   noEmit: false,
@@ -537,6 +584,7 @@ const fixedCompilerOptions = {
 const noop = () => {
 };
 const extPrefix = (file) => mtjsRE.test(file) ? "m" : ctjsRE.test(file) ? "c" : "";
+const tsToDts = (path) => `${path.replace(tsRE, "")}.d.ts`;
 const regexpSymbolRE = /([$.\\+?()[\]!<=|{}^,])/g;
 const asteriskRE = /[*]+/g;
 function dtsPlugin(options = {}) {
@@ -587,8 +635,11 @@ function dtsPlugin(options = {}) {
   const outputFiles = /* @__PURE__ */ new Map();
   const rollupConfig = { ...options.rollupConfig || {} };
   rollupConfig.bundledPackages = rollupConfig.bundledPackages || options.bundledPackages || [];
+  const cleanPath = (path) => {
+    return cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path;
+  };
   return {
-    name: "vite:dts",
+    name: pluginName,
     apply: "build",
     enforce: "pre",
     config(config) {
@@ -743,12 +794,16 @@ ${logPrefix} ${yellow(
       publicRoot = normalizePath(publicRoot);
       entryRoot = entryRoot || publicRoot;
       entryRoot = ensureAbsolute(entryRoot, root);
-      const diagnostics = program.getDeclarationDiagnostics();
+      const diagnostics = [
+        ...program.getDeclarationDiagnostics(),
+        ...program.getSemanticDiagnostics(),
+        ...program.getSyntacticDiagnostics()
+      ];
       if (diagnostics?.length) {
         logger.error(ts.formatDiagnosticsWithColorAndContext(diagnostics, host));
       }
       if (typeof afterDiagnostic === "function") {
-        await wrapPromise(afterDiagnostic(diagnostics));
+        await unwrapPromise(afterDiagnostic(diagnostics));
       }
       rootNames.forEach((file) => {
         this.addWatchFile(file);
@@ -824,9 +879,10 @@ ${logPrefix} Start generate declaration files...`));
       const startTime = Date.now();
       const outDir = outDirs[0];
       const emittedFiles = /* @__PURE__ */ new Map();
+      const declareModules = [];
       const writeOutput = async (path, content, outDir2, record = true) => {
         if (typeof beforeWriteFile === "function") {
-          const result = await wrapPromise(beforeWriteFile(path, content));
+          const result = await unwrapPromise(beforeWriteFile(path, content));
           if (result === false)
             return;
           if (result) {
@@ -870,17 +926,27 @@ ${logPrefix} Start generate declaration files...`));
       await runParallel(
         cpus().length,
         Array.from(outputFiles.entries()),
-        async ([path, content]) => {
-          const isMapFile = path.endsWith(".map");
-          const baseDir = dirname(path);
+        async ([filePath, content]) => {
+          const isMapFile = filePath.endsWith(".map");
+          const baseDir = dirname(filePath);
           if (!isMapFile && content) {
-            content = clearPureImport ? removePureImport(content) : content;
-            content = transformAliasImport(path, content, aliases, aliasesExclude);
-            content = staticImport || rollupTypes ? transformDynamicImport(content) : content;
+            const result = transformCode({
+              filePath,
+              content,
+              aliases,
+              aliasesExclude,
+              staticImport,
+              clearPureImport
+            });
+            content = result.content;
+            declareModules.push(...result.declareModules);
           }
-          path = resolve(
+          filePath = resolve(
             outDir,
-            relative(entryRoot, cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path)
+            relative(
+              entryRoot,
+              cleanVueFileName ? filePath.replace(".vue.d.ts", ".d.ts") : filePath
+            )
           );
           content = cleanVueFileName ? content.replace(vuePathRE, '"$1"') : content;
           if (isMapFile) {
@@ -889,17 +955,17 @@ ${logPrefix} Start generate declaration files...`));
               sourceMap.sources = sourceMap.sources.map((source) => {
                 return normalizePath(
                   relative(
-                    dirname(path),
+                    dirname(filePath),
                     resolve(currentDir, relative(publicRoot, baseDir), source)
                   )
                 );
               });
               content = JSON.stringify(sourceMap);
             } catch (e) {
-              logger.warn(`${logPrefix} ${yellow("Processing source map fail:")} ${path}`);
+              logger.warn(`${logPrefix} ${yellow("Processing source map fail:")} ${filePath}`);
             }
           }
-          await writeOutput(path, content, outDir);
+          await writeOutput(filePath, content, outDir);
         }
       );
       bundleDebug("write output");
@@ -913,9 +979,6 @@ ${logPrefix} Start generate declaration files...`));
         const entryNames = Object.keys(entries);
         const types = findTypesPath(pkg.publishConfig, pkg);
         const multiple = entryNames.length > 1;
-        const cleanPath = (path) => {
-          return cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path;
-        };
         let typesPath = cleanPath(types ? resolve(root, types) : resolve(outDir, indexName));
         if (!multiple && !dtsRE.test(typesPath)) {
           logger.warn(
@@ -928,23 +991,23 @@ ${logPrefix} ${yellow(
           typesPath = `${typesPath.replace(tjsRE, "")}.d.${extPrefix(typesPath)}ts`;
         }
         for (const name of entryNames) {
-          const path = multiple ? cleanPath(resolve(outDir, `${name.replace(tsRE, "")}.d.ts`)) : typesPath;
-          if (existsSync(path))
+          const entryDtsPath = multiple ? cleanPath(resolve(outDir, tsToDts(name))) : typesPath;
+          if (existsSync(entryDtsPath))
             continue;
-          const index = cleanPath(
-            resolve(outDir, relative(entryRoot, `${entries[name].replace(tsRE, "")}.d.ts`))
+          const sourceEntry = normalizePath(
+            cleanPath(resolve(outDir, relative(entryRoot, tsToDts(entries[name]))))
           );
-          let fromPath = normalizePath(relative(dirname(path), index));
+          let fromPath = normalizePath(relative(dirname(entryDtsPath), sourceEntry));
           fromPath = fromPath.replace(dtsRE, "");
           fromPath = fullRelativeRE.test(fromPath) ? fromPath : `./${fromPath}`;
           let content = `export * from '${fromPath}'
 `;
-          if (existsSync(index) && hasExportDefault(await readFile(index, "utf-8"))) {
+          if (emittedFiles.has(sourceEntry) && hasExportDefault(emittedFiles.get(sourceEntry))) {
             content += `import ${libName} from '${fromPath}'
 export default ${libName}
 `;
           }
-          await writeOutput(cleanPath(path), content, outDir);
+          await writeOutput(cleanPath(entryDtsPath), content, outDir);
         }
         bundleDebug("insert index");
         if (rollupTypes) {
@@ -962,7 +1025,7 @@ export default ${libName}
           const compilerOptions2 = configPath ? getTsConfig(configPath, host.readFile).compilerOptions : rawCompilerOptions;
           if (multiple) {
             for (const name of entryNames) {
-              const path = cleanPath(resolve(outDir, `${name.replace(tsRE, "")}.d.ts`));
+              const path = cleanPath(resolve(outDir, tsToDts(name)));
               rollupDeclarationFiles({
                 root,
                 configPath,
@@ -995,9 +1058,16 @@ export default ${libName}
           await runParallel(cpus().length, Array.from(emittedFiles.keys()), (f) => unlink(f));
           removeDirIfEmpty(outDir);
           emittedFiles.clear();
-          for (const file of rollupFiles) {
-            emittedFiles.set(file, await readFile(file, "utf-8"));
-          }
+          const declared = declareModules.join("\n");
+          await runParallel(cpus().length, [...rollupFiles], async (filePath) => {
+            await writeOutput(
+              filePath,
+              await readFile(filePath, "utf-8") + (declared ? `
+${declared}
+` : ""),
+              dirname(filePath)
+            );
+          });
           bundleDebug("rollup output");
         }
       }
@@ -1019,7 +1089,7 @@ export default ${libName}
         });
       }
       if (typeof afterBuild === "function") {
-        await wrapPromise(afterBuild(emittedFiles));
+        await unwrapPromise(afterBuild(emittedFiles));
       }
       bundleDebug("finish");
       logger.info(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-dts",
-  "version": "3.7.2",
+  "version": "3.8.0",
   "type": "module",
   "license": "MIT",
   "author": "qmhc",
@@ -58,43 +58,44 @@
     "volar"
   ],
   "dependencies": {
-    "@microsoft/api-extractor": "7.39.0",
+    "@microsoft/api-extractor": "7.43.0",
     "@rollup/pluginutils": "^5.1.0",
-    "@vue/language-core": "^1.8.26",
+    "@vue/language-core": "^1.8.27",
     "debug": "^4.3.4",
     "kolorist": "^1.8.0",
-    "vue-tsc": "^1.8.26"
+    "magic-string": "^0.30.8",
+    "vue-tsc": "^1.8.27"
   },
   "devDependencies": {
-    "@commitlint/cli": "^18.4.3",
+    "@commitlint/cli": "^19.2.1",
     "@types/debug": "^4.1.12",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^20.10.5",
+    "@types/node": "^20.11.30",
     "@types/prompts": "^2.4.9",
-    "@types/semver": "^7.5.6",
-    "@vexip-ui/commitlint-config": "^0.3.0",
-    "@vexip-ui/eslint-config": "^0.11.0",
+    "@types/semver": "^7.5.8",
+    "@vexip-ui/commitlint-config": "^0.4.0",
+    "@vexip-ui/eslint-config": "^0.12.0",
     "@vexip-ui/prettier-config": "^0.2.0",
     "@vue/eslint-config-standard": "^8.0.1",
-    "@vue/eslint-config-typescript": "^12.0.0",
+    "@vue/eslint-config-typescript": "^13.0.0",
     "conventional-changelog-cli": "^4.1.0",
-    "eslint": "^8.56.0",
+    "eslint": "^8.57.0",
     "execa": "^8.0.1",
-    "husky": "^8.0.3",
+    "husky": "^9.0.11",
     "is-ci": "^3.0.1",
-    "lint-staged": "^15.2.0",
+    "lint-staged": "^15.2.2",
     "minimist": "^1.2.8",
     "pinst": "^3.0.0",
-    "prettier": "^3.1.1",
-    "pretty-quick": "^3.1.3",
+    "prettier": "^3.2.5",
+    "pretty-quick": "^4.0.0",
     "prompts": "^2.4.2",
     "rimraf": "^5.0.5",
-    "semver": "^7.5.4",
-    "tsx": "^4.7.0",
-    "typescript": "5.2.2",
+    "semver": "^7.6.0",
+    "tsx": "^4.7.1",
+    "typescript": "5.4.3",
     "unbuild": "^2.0.0",
-    "vite": "^5.0.10",
-    "vitest": "^1.1.0"
+    "vite": "^5.2.6",
+    "vitest": "^1.4.0"
   },
   "peerDependencies": {
     "typescript": "*",
@@ -107,7 +108,7 @@
   },
   "pnpm": {
     "patchedDependencies": {
-      "@microsoft/api-extractor@7.39.0": "patches/@microsoft__api-extractor@7.39.0.patch"
+      "@microsoft/api-extractor@7.43.0": "patches/@microsoft__api-extractor@7.43.0.patch"
     }
   }
 }