vite-plugin-dts 3.7.3 → 3.8.0

package/dist/index.cjs

@@ -13,11 +13,13 @@ const vueTsc = require('vue-tsc');
 const debug = require('debug');
 const kolorist = require('kolorist');
 const apiExtractor = require('@microsoft/api-extractor');
+const MagicString = require('magic-string');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
 const debug__default = /*#__PURE__*/_interopDefaultCompat(debug);
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 
 const windowsSlashRE = /\\+/g;
 function slash(p) {
@@ -38,7 +40,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) {
@@ -415,46 +417,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))
@@ -465,54 +434,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 = node_path.isAbsolute(matchedAlias.replacement) ? normalizePath(node_path.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(node_path.relative(dir, node_path.resolve(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 = node_path.dirname(filePath);
-        const replacement = node_path.isAbsolute(matchedAlias.replacement) ? normalizePath(node_path.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(node_path.relative(dir, node_path.resolve(dir, truthPath)));
-        return str.replace(
-          isDynamic ? simpleDynamicImportRE : simpleStaticImportRE,
-          `$1'${ensureStartWithDot(normalizedPath)}'${isDynamic ? ")" : ""}`
+  }
+  return importer;
+}
+function transformCode(options) {
+  const s = new MagicString__default(options.content);
+  const ast = ts__default.createSourceFile("a.ts", options.content, ts__default.ScriptTarget.Latest);
+  const dir = node_path.dirname(options.filePath);
+  const importMap = /* @__PURE__ */ new Map();
+  const usedDefault = /* @__PURE__ */ new Map();
+  const declareModules = [];
+  let indexCount = 0;
+  walkSourceFile(ast, (node, parent) => {
+    if (ts__default.isImportDeclaration(node)) {
+      if (!node.importClause) {
+        options.clearPureImport && s.remove(node.pos, node.end);
+      } else if (ts__default.isStringLiteral(node.moduleSpecifier) && (node.importClause.name || node.importClause.namedBindings && ts__default.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__default.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__default.isImportTypeNode(node) && node.qualifier && ts__default.isLiteralTypeNode(node.argument) && ts__default.isIdentifier(node.qualifier) && ts__default.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__default.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__default.isCallExpression(node) && node.expression.kind === ts__default.SyntaxKind.ImportKeyword && ts__default.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__default.isExportDeclaration(node) && node.moduleSpecifier && ts__default.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__default.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__default.createSourceFile("a.ts", content, ts__default.ScriptTarget.Latest);
+  let has = false;
+  walkSourceFile(ast, (node) => {
+    if (ts__default.isExportAssignment(node)) {
+      has = true;
+    } else if (ts__default.isExportDeclaration(node) && node.exportClause && ts__default.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?$/;
@@ -523,7 +570,8 @@ const mtjsRE = /\.m(t|j)sx?$/;
 const ctjsRE = /\.c(t|j)sx?$/;
 const fullRelativeRE = /^\.\.?\//;
 const defaultIndex = "index.d.ts";
-const logPrefix = kolorist.cyan("[vite:dts]");
+const pluginName = "vite:dts";
+const logPrefix = kolorist.cyan(`[${pluginName}]`);
 const bundleDebug = debug__default("vite-plugin-dts:bundle");
 const fixedCompilerOptions = {
   noEmit: false,
@@ -539,6 +587,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 = {}) {
@@ -589,8 +638,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) {
@@ -745,12 +797,16 @@ ${logPrefix} ${kolorist.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__default.formatDiagnosticsWithColorAndContext(diagnostics, host));
       }
       if (typeof afterDiagnostic === "function") {
-        await wrapPromise(afterDiagnostic(diagnostics));
+        await unwrapPromise(afterDiagnostic(diagnostics));
       }
       rootNames.forEach((file) => {
         this.addWatchFile(file);
@@ -826,9 +882,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) {
@@ -872,17 +929,27 @@ ${logPrefix} Start generate declaration files...`));
       await runParallel(
         node_os.cpus().length,
         Array.from(outputFiles.entries()),
-        async ([path, content]) => {
-          const isMapFile = path.endsWith(".map");
-          const baseDir = node_path.dirname(path);
+        async ([filePath, content]) => {
+          const isMapFile = filePath.endsWith(".map");
+          const baseDir = node_path.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,
-            node_path.relative(entryRoot, cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path)
+            node_path.relative(
+              entryRoot,
+              cleanVueFileName ? filePath.replace(".vue.d.ts", ".d.ts") : filePath
+            )
           );
           content = cleanVueFileName ? content.replace(vuePathRE, '"$1"') : content;
           if (isMapFile) {
@@ -891,17 +958,17 @@ ${logPrefix} Start generate declaration files...`));
               sourceMap.sources = sourceMap.sources.map((source) => {
                 return normalizePath(
                   node_path.relative(
-                    node_path.dirname(path),
+                    node_path.dirname(filePath),
                     resolve(currentDir, node_path.relative(publicRoot, baseDir), source)
                   )
                 );
               });
               content = JSON.stringify(sourceMap);
             } catch (e) {
-              logger.warn(`${logPrefix} ${kolorist.yellow("Processing source map fail:")} ${path}`);
+              logger.warn(`${logPrefix} ${kolorist.yellow("Processing source map fail:")} ${filePath}`);
             }
           }
-          await writeOutput(path, content, outDir);
+          await writeOutput(filePath, content, outDir);
         }
       );
       bundleDebug("write output");
@@ -915,9 +982,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(
@@ -930,23 +994,23 @@ ${logPrefix} ${kolorist.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 (node_fs.existsSync(path))
+          const entryDtsPath = multiple ? cleanPath(resolve(outDir, tsToDts(name))) : typesPath;
+          if (node_fs.existsSync(entryDtsPath))
             continue;
-          const index = cleanPath(
-            resolve(outDir, node_path.relative(entryRoot, `${entries[name].replace(tsRE, "")}.d.ts`))
+          const sourceEntry = normalizePath(
+            cleanPath(resolve(outDir, node_path.relative(entryRoot, tsToDts(entries[name]))))
           );
-          let fromPath = normalizePath(node_path.relative(node_path.dirname(path), index));
+          let fromPath = normalizePath(node_path.relative(node_path.dirname(entryDtsPath), sourceEntry));
           fromPath = fromPath.replace(dtsRE, "");
           fromPath = fullRelativeRE.test(fromPath) ? fromPath : `./${fromPath}`;
           let content = `export * from '${fromPath}'
 `;
-          if (node_fs.existsSync(index) && hasExportDefault(await promises.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) {
@@ -964,7 +1028,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,
@@ -997,9 +1061,16 @@ export default ${libName}
           await runParallel(node_os.cpus().length, Array.from(emittedFiles.keys()), (f) => promises.unlink(f));
           removeDirIfEmpty(outDir);
           emittedFiles.clear();
-          for (const file of rollupFiles) {
-            emittedFiles.set(file, await promises.readFile(file, "utf-8"));
-          }
+          const declared = declareModules.join("\n");
+          await runParallel(node_os.cpus().length, [...rollupFiles], async (filePath) => {
+            await writeOutput(
+              filePath,
+              await promises.readFile(filePath, "utf-8") + (declared ? `
+${declared}
+` : ""),
+              node_path.dirname(filePath)
+            );
+          });
           bundleDebug("rollup output");
         }
       }
@@ -1021,7 +1092,7 @@ export default ${libName}
         });
       }
       if (typeof afterBuild === "function") {
-        await wrapPromise(afterBuild(emittedFiles));
+        await unwrapPromise(afterBuild(emittedFiles));
       }
       bundleDebug("finish");
       logger.info(