vite-plugin-dts 1.6.6 → 1.7.1

package/dist/index.cjs

@@ -12,6 +12,7 @@ const require$$1$1 = require('fs');
 const require$$1 = require('path');
 const require$$5 = require('buffer');
 const require$$7 = require('inspector');
+const pluginutils = require('@rollup/pluginutils');
 const node_fs = require('node:fs');
 const node_module = require('node:module');
 const apiExtractor = require('@microsoft/api-extractor');
@@ -21,17 +22,6 @@ const SourceMapper_js = require('@microsoft/api-extractor/lib/collector/SourceMa
 const DtsRollupGenerator_js = require('@microsoft/api-extractor/lib/generators/DtsRollupGenerator.js');
 const nodeCoreLibrary = require('@rushstack/node-core-library');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-const os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-const glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
-const debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
-const require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
-const require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-const require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
-const require$$7__default = /*#__PURE__*/_interopDefaultLegacy(require$$7);
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -3370,7 +3360,7 @@ function requireSourceMapSupport () {
 	hasRequiredSourceMapSupport = 1;
 	(function (module, exports) {
 		var SourceMapConsumer = requireSourceMap().SourceMapConsumer;
-		var path = require$$1__default;
+		var path = require$$1;
 
 		var fs;
 		try {
@@ -11055,9 +11045,9 @@ and limitations under the License.
 	        var byteOrderMarkIndicator = "\uFEFF";
 	        function getNodeSystem() {
 	            var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/;
-	            var _fs = require$$1__default$1;
-	            var _path = require$$1__default;
-	            var _os = os__default;
+	            var _fs = require$$1$1;
+	            var _path = require$$1;
+	            var _os = os;
 	            // crypto can be absent on reduced node installations
 	            var _crypto;
 	            try {
@@ -11068,7 +11058,7 @@ and limitations under the License.
 	            }
 	            var activeSession;
 	            var profilePath = "./profile.cpuprofile";
-	            var Buffer = require$$5__default.Buffer;
+	            var Buffer = require$$5.Buffer;
 	            var nodeVersion = getNodeMajorVersion();
 	            var isNode4OrLater = nodeVersion >= 4;
 	            var isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
@@ -11221,7 +11211,7 @@ and limitations under the License.
 	                    cb();
 	                    return false;
 	                }
-	                var inspector = require$$7__default;
+	                var inspector = require$$7;
 	                if (!inspector || !inspector.Session) {
 	                    cb();
 	                    return false;
@@ -176693,6 +176683,10 @@ function requireCompiler() {
       try {
         compiler = _require(_require.resolve("vue/compiler-sfc", { paths: [compileRoot] }));
       } catch (e) {
+        try {
+          compiler = _require(_require.resolve("@vue/compiler-sfc", { paths: [compileRoot] }));
+        } catch (e2) {
+        }
       }
     }
     if (!compiler) {
@@ -176776,7 +176770,7 @@ const _sfc_main = ${classMatch[1]}`;
       content = rewriteDefault(
         script.content,
         "_sfc_main",
-        script.lang === "ts" ? ["typescript"] : void 0
+        script.lang === "ts" ? ["typescript", "decorators-legacy"] : void 0
       );
       content += "\nexport default _sfc_main\n";
       ext = script.lang || "js";
@@ -176871,19 +176865,18 @@ function rollupDeclarationFiles({
 }
 
 const noneExport = "export {};\n";
-const virtualPrefix = "\0";
 const vueRE = /\.vue$/;
-const tsRE = /\.tsx?$/;
-const jsRE = /\.jsx?$/;
+const tsRE = /\.(m|c)?tsx?$/;
+const jsRE = /\.(m|c)?jsx?$/;
 const dtsRE = /\.d\.tsx?$/;
-const tjsRE = /\.(t|j)sx?$/;
-const watchExtensionRE = /\.(vue|(t|j)sx?)$/;
+const tjsRE = /\.(m|c)?(t|j)sx?$/;
+const watchExtensionRE = /\.(vue|(m|c)?(t|j)sx?)$/;
 const fullRelativeRE = /^\.\.?\//;
 const defaultIndex = "index.d.ts";
 const noop = () => {
 };
 const logPrefix = kolorist.cyan("[vite:dts]");
-const bundleDebug = debug__default("vite-plugin-dts:bundle");
+const bundleDebug = debug("vite-plugin-dts:bundle");
 function dtsPlugin(options = {}) {
   const {
     tsConfigFilePath = "tsconfig.json",
@@ -176894,9 +176887,10 @@ function dtsPlugin(options = {}) {
     insertTypesEntry = false,
     rollupTypes = false,
     noEmitOnError = false,
-    skipDiagnostics = true,
-    logDiagnostics = false,
+    skipDiagnostics = false,
+    logDiagnostics = void 0,
     copyDtsFiles = true,
+    libFolderPath = void 0,
     afterDiagnostic = noop,
     beforeWriteFile = noop,
     afterBuild = noop
@@ -176913,6 +176907,9 @@ function dtsPlugin(options = {}) {
   let tsConfigPath;
   let outputDirs;
   let isBundle = false;
+  let include;
+  let exclude;
+  let filter;
   const sourceDtsFiles = /* @__PURE__ */ new Set();
   let hasJsVue = false;
   let allowJs = false;
@@ -176943,6 +176940,17 @@ function dtsPlugin(options = {}) {
       if (isBundle)
         return;
       logger = config.logger;
+      if (logDiagnostics != null) {
+        logger.warn(
+          kolorist.yellow(
+            `
+${kolorist.cyan(
+              "[vite:dts]"
+            )} 'logDiagnostics' has been deprecated, the original feature now following 'skipDiagnostics'.
+`
+          )
+        );
+      }
       if (!config.build.lib) {
         logger.warn(
           kolorist.yellow(
@@ -176957,8 +176965,9 @@ ${kolorist.cyan(
         indexName = defaultIndex;
       } else {
         const filename = config.build.lib.fileName ?? defaultIndex;
+        const entry = typeof config.build.lib.entry === "string" ? config.build.lib.entry : Object.values(config.build.lib.entry)[0];
         libName = config.build.lib.name || "_default";
-        indexName = typeof filename === "string" ? filename : filename("es");
+        indexName = typeof filename === "string" ? filename : filename("es", entry);
         if (!dtsRE.test(indexName)) {
           indexName = `${tjsRE.test(indexName) ? indexName.replace(tjsRE, "") : indexName}.d.ts`;
         }
@@ -176991,17 +177000,33 @@ ${kolorist.cyan(
           emitDeclarationOnly: true
         }),
         tsConfigFilePath: tsConfigPath,
-        skipAddingFilesFromTsConfig: true
+        skipAddingFilesFromTsConfig: true,
+        libFolderPath: libFolderPath ? ensureAbsolute(libFolderPath, root) : void 0
       });
       allowJs = project.getCompilerOptions().allowJs ?? false;
+      const tsConfig = typescript.readConfigFile(tsConfigPath, project.getFileSystem().readFileSync).config ?? {};
+      const parentTsConfigPath = tsConfig.extends && ensureAbsolute(tsConfig.extends, root);
+      const parentTsConfig = parentTsConfigPath ? typescript.readConfigFile(parentTsConfigPath, project.getFileSystem().readFileSync).config : {};
+      include = ensureArray(
+        options.include ?? tsConfig.include ?? parentTsConfig.include ?? "**/*"
+      ).map(normalizeGlob);
+      exclude = ensureArray(
+        options.exclude ?? tsConfig.exclude ?? parentTsConfig.exclude ?? "node_modules/**"
+      ).map(normalizeGlob);
+      filter = pluginutils.createFilter(include, exclude, { resolve: root });
     },
     buildStart(inputOptions) {
-      if (!isBundle && (insertTypesEntry || rollupTypes)) {
-        entries = Array.isArray(inputOptions.input) ? inputOptions.input : Object.values(inputOptions.input);
+      if (Array.isArray(inputOptions.input)) {
+        entries = inputOptions.input.reduce((prev, current) => {
+          prev[node_path.basename(current)] = current;
+          return prev;
+        }, {});
+      } else {
+        entries = { ...inputOptions.input };
       }
     },
     transform(code, id) {
-      if (id.startsWith(virtualPrefix)) {
+      if (!filter(id)) {
         return null;
       }
       if (vueRE.test(id)) {
@@ -177012,7 +177037,7 @@ ${kolorist.cyan(
           project.createSourceFile(`${id}.${ext || "js"}`, content, { overwrite: true });
         }
       } else if (!id.includes(".vue?vue") && (tsRE.test(id) || allowJs && jsRE.test(id))) {
-        project.addSourceFileAtPath(id);
+        project.createSourceFile(id, code, { overwrite: true });
       }
       return null;
     },
@@ -177034,18 +177059,12 @@ ${logPrefix} Start generate declaration files...`));
       isBundle = true;
       sourceDtsFiles.clear();
       const startTime = Date.now();
-      const tsConfig = typescript.readConfigFile(tsConfigPath, project.getFileSystem().readFileSync).config ?? {};
-      const parentTsConfigPath = tsConfig.extends && ensureAbsolute(tsConfig.extends, root);
-      const parentTsConfig = parentTsConfigPath ? typescript.readConfigFile(parentTsConfigPath, project.getFileSystem().readFileSync).config : {};
-      const include = options.include ?? tsConfig.include ?? parentTsConfig.include ?? "**/*";
-      const exclude = options.exclude ?? tsConfig.exclude ?? parentTsConfig.exclude ?? "node_modules/**";
-      bundleDebug("read config");
       const includedFileSet = /* @__PURE__ */ new Set();
       if (include && include.length) {
-        const files = await glob__default(ensureArray(include).map(normalizeGlob), {
+        const files = await glob(include, {
           cwd: root,
           absolute: true,
-          ignore: ensureArray(exclude).map(normalizeGlob)
+          ignore: exclude
         });
         files.forEach((file) => {
           if (dtsRE.test(file)) {
@@ -177076,7 +177095,7 @@ ${logPrefix} Start generate declaration files...`));
       bundleDebug("resolve");
       if (!skipDiagnostics) {
         const diagnostics = project.getPreEmitDiagnostics();
-        if (diagnostics?.length && logDiagnostics) {
+        if (diagnostics?.length) {
           logger.warn(project.formatDiagnosticsWithColorAndContext(diagnostics));
         }
         if (typeof afterDiagnostic === "function") {
@@ -177103,7 +177122,7 @@ ${logPrefix} Start generate declaration files...`));
       entryRoot = ensureAbsolute(entryRoot, root);
       const wroteFiles = /* @__PURE__ */ new Set();
       const outputDir = outputDirs[0];
-      await runParallel(os__default.cpus().length, outputFiles, async (outputFile) => {
+      await runParallel(os.cpus().length, outputFiles, async (outputFile) => {
         let filePath = outputFile.path;
         let content = outputFile.content;
         const isMapFile = filePath.endsWith(".map");
@@ -177128,8 +177147,8 @@ ${logPrefix} Start generate declaration files...`));
             content = result.content ?? content;
           }
         }
-        await fs__default.mkdir(node_path.dirname(filePath), { recursive: true });
-        await fs__default.writeFile(
+        await fs.mkdir(node_path.dirname(filePath), { recursive: true });
+        await fs.writeFile(
           filePath,
           cleanVueFileName ? content.replace(/['"](.+)\.vue['"]/g, '"$1"') : content,
           "utf-8"
@@ -177139,59 +177158,87 @@ ${logPrefix} Start generate declaration files...`));
       bundleDebug("output");
       if (insertTypesEntry || rollupTypes) {
         const pkgPath = node_path.resolve(root, "package.json");
-        const pkg = fs__default.existsSync(pkgPath) ? JSON.parse(await fs__default.readFile(pkgPath, "utf-8")) : {};
+        const pkg = fs.existsSync(pkgPath) ? JSON.parse(await fs.readFile(pkgPath, "utf-8")) : {};
+        const entryNames = Object.keys(entries);
         const types = pkg.types || pkg.typings;
-        let typesPath = types ? node_path.resolve(root, types) : node_path.resolve(outputDir, indexName);
-        if (!fs__default.existsSync(typesPath)) {
-          const entry = entries[0];
-          const outputIndex = node_path.resolve(outputDir, node_path.relative(entryRoot, entry.replace(tsRE, ".d.ts")));
-          let filePath = vite.normalizePath(node_path.relative(node_path.dirname(typesPath), outputIndex));
-          filePath = filePath.replace(dtsRE, "");
-          filePath = fullRelativeRE.test(filePath) ? filePath : `./${filePath}`;
-          let content = `export * from '${filePath}'
+        const multiple = entryNames.length > 1;
+        const typesPath = types ? node_path.resolve(root, types) : node_path.resolve(outputDir, indexName);
+        for (const name of entryNames) {
+          let filePath = multiple ? node_path.resolve(outputDir, name.replace(tsRE, ".d.ts")) : typesPath;
+          if (fs.existsSync(filePath))
+            continue;
+          const index = node_path.resolve(
+            outputDir,
+            node_path.relative(entryRoot, entries[name].replace(tsRE, ".d.ts"))
+          );
+          let fromPath = vite.normalizePath(node_path.relative(node_path.dirname(filePath), index));
+          fromPath = fromPath.replace(dtsRE, "");
+          fromPath = fullRelativeRE.test(fromPath) ? fromPath : `./${fromPath}`;
+          let content = `export * from '${fromPath}'
 `;
-          if (fs__default.existsSync(outputIndex)) {
-            const entryCodes = await fs__default.readFile(outputIndex, "utf-8");
+          if (fs.existsSync(index)) {
+            const entryCodes = await fs.readFile(index, "utf-8");
             if (entryCodes.includes("export default")) {
-              content += `import ${libName} from '${filePath}'
+              content += `import ${libName} from '${fromPath}'
 export default ${libName}
 `;
             }
           }
           let result;
           if (typeof beforeWriteFile === "function") {
-            result = beforeWriteFile(typesPath, content);
+            result = beforeWriteFile(filePath, content);
             if (result && isNativeObj(result)) {
-              typesPath = result.filePath ?? typesPath;
+              filePath = result.filePath ?? filePath;
               content = result.content ?? content;
             }
           }
           if (result !== false) {
-            await fs__default.writeFile(typesPath, content, "utf-8");
-            wroteFiles.add(vite.normalizePath(typesPath));
+            await fs.writeFile(filePath, content, "utf-8");
+            wroteFiles.add(vite.normalizePath(filePath));
           }
         }
         bundleDebug("insert index");
         if (rollupTypes) {
           logger.info(kolorist.green(`${logPrefix} Start rollup declaration files...`));
-          rollupDeclarationFiles({
-            root,
-            tsConfigPath,
-            compilerOptions,
-            outputDir,
-            entryPath: typesPath,
-            fileName: node_path.basename(typesPath)
-          });
-          const wroteFile = vite.normalizePath(typesPath);
-          wroteFiles.delete(wroteFile);
-          await runParallel(os__default.cpus().length, Array.from(wroteFiles), (f) => fs__default.unlink(f));
+          const rollupFiles = /* @__PURE__ */ new Set();
+          if (multiple) {
+            for (const name of entryNames) {
+              const path = node_path.resolve(outputDir, name.replace(tsRE, ".d.ts"));
+              rollupDeclarationFiles({
+                root,
+                tsConfigPath,
+                compilerOptions,
+                outputDir,
+                entryPath: path,
+                fileName: node_path.basename(path)
+              });
+              const wroteFile = vite.normalizePath(path);
+              wroteFiles.delete(wroteFile);
+              rollupFiles.add(wroteFile);
+            }
+          } else {
+            rollupDeclarationFiles({
+              root,
+              tsConfigPath,
+              compilerOptions,
+              outputDir,
+              entryPath: typesPath,
+              fileName: node_path.basename(typesPath)
+            });
+            const wroteFile = vite.normalizePath(typesPath);
+            wroteFiles.delete(wroteFile);
+            rollupFiles.add(wroteFile);
+          }
+          await runParallel(os.cpus().length, Array.from(wroteFiles), (f) => fs.unlink(f));
           removeDirIfEmpty(outputDir);
           wroteFiles.clear();
-          wroteFiles.add(wroteFile);
+          for (const file of rollupFiles) {
+            wroteFiles.add(file);
+          }
           if (copyDtsFiles) {
-            await runParallel(os__default.cpus().length, dtsOutputFiles, async ({ path, content }) => {
+            await runParallel(os.cpus().length, dtsOutputFiles, async ({ path, content }) => {
               const filePath = node_path.resolve(outputDir, node_path.basename(path));
-              await fs__default.writeFile(filePath, content, "utf-8");
+              await fs.writeFile(filePath, content, "utf-8");
               wroteFiles.add(vite.normalizePath(filePath));
             });
           }
@@ -177200,14 +177247,14 @@ export default ${libName}
       }
       if (outputDirs.length > 1) {
         const dirs = outputDirs.slice(1);
-        await runParallel(os__default.cpus().length, Array.from(wroteFiles), async (wroteFile) => {
+        await runParallel(os.cpus().length, Array.from(wroteFiles), async (wroteFile) => {
           const relativePath = node_path.relative(outputDir, wroteFile);
-          const content = await fs__default.readFile(wroteFile, "utf-8");
+          const content = await fs.readFile(wroteFile, "utf-8");
           await Promise.all(
             dirs.map(async (dir) => {
               const filePath = node_path.resolve(dir, relativePath);
-              await fs__default.mkdir(node_path.dirname(filePath), { recursive: true });
-              await fs__default.writeFile(filePath, content, "utf-8");
+              await fs.mkdir(node_path.dirname(filePath), { recursive: true });
+              await fs.writeFile(filePath, content, "utf-8");
             })
           );
         });

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from 'vite';
+import * as vite from 'vite';
 import { ts, Diagnostic } from 'ts-morph';
 
 interface TransformWriteFile {
@@ -6,27 +6,169 @@ interface TransformWriteFile {
     content?: string;
 }
 interface PluginOptions {
-    include?: string | string[];
-    exclude?: string | string[];
+    /**
+     * Depends on the root directory
+     *
+     * Defaults base on your vite config root options
+     */
     root?: string;
+    /**
+     * Declaration files output directory
+     *
+     * Can be specified a array to output to multiple directories
+     *
+     * Defaults base on your vite config output options
+     */
     outputDir?: string | string[];
+    /**
+     * Manually set the root path of the entry files
+     *
+     * The output path of each file will be caculated base on it
+     *
+     * Defaults is the smallest public path for all files
+     */
     entryRoot?: string;
+    /**
+     * Project init compilerOptions using by ts-morph
+     *
+     * @default null
+     */
     compilerOptions?: ts.CompilerOptions | null;
+    /**
+     * Project init tsconfig.json file path by ts-morph
+     *
+     * Plugin also resolve incldue and exclude files from tsconfig.json
+     *
+     * @default 'tsconfig.json'
+     */
     tsConfigFilePath?: string;
+    /**
+     * Set which paths should exclude when transform aliases
+     *
+     * If it's regexp, it will test the original import path directly
+     *
+     * @default []
+     */
     aliasesExclude?: (string | RegExp)[];
+    /**
+     * Whether transform file name '.vue.d.ts' to '.d.ts'
+     *
+     * @default false
+     */
     cleanVueFileName?: boolean;
+    /**
+     * Whether transform dynamic import to static
+     *
+     * Force true when `rollupTypes` is effective
+     *
+     * eg. 'import('vue').DefineComponent' to 'import { DefineComponent } from "vue"'
+     *
+     * @default false
+     */
     staticImport?: boolean;
+    /**
+     * Manual set include glob
+     *
+     * Defaults base on your tsconfig.json include option
+     */
+    include?: string | string[];
+    /**
+     * Manual set exclude glob
+     *
+     * Defaults base on your tsconfig.json exclude option, be 'node_module/**' when empty
+     */
+    exclude?: string | string[];
+    /**
+     * Do not emit if content of file only includes 'export {}'
+     *
+     * @default true
+     */
     clearPureImport?: boolean;
+    /**
+     * Whether generate types entry file
+     *
+     * When true will from package.json types field if exists or `${outputDir}/index.d.ts`
+     *
+     * Force true when `rollupTypes` is effective
+     *
+     * @default false
+     */
     insertTypesEntry?: boolean;
+    /**
+     * Set to rollup declaration files after emit
+     *
+     * Power by `@microsoft/api-extractor`, it will start a new program which takes some time
+     *
+     * @default false
+     */
     rollupTypes?: boolean;
+    /**
+     * Whether copy .d.ts source files into outputDir
+     *
+     * @default true
+     */
     copyDtsFiles?: boolean;
+    /**
+     * Whether emit nothing when has any diagnostic
+     *
+     * @default false
+     */
     noEmitOnError?: boolean;
+    /**
+     * Whether skip typescript diagnostics
+     *
+     * Skip type diagnostics means that type errors will not interrupt the build process
+     *
+     * But for the source files with type errors will not be emitted
+     *
+     * @default false
+     */
     skipDiagnostics?: boolean;
+    /**
+     * Whether log diagnostic informations
+     *
+     * Not effective when `skipDiagnostics` is true
+     *
+     * @deprecated
+     * @default false
+     */
     logDiagnostics?: boolean;
+    /**
+     * Customize typescript lib folder path
+     *
+     * Should pass a relative path to root or a absolute path
+     *
+     * @default undefined
+     */
+    libFolderPath?: string;
+    /**
+     * After emit diagnostic hook
+     *
+     * According to the length to judge whether there is any type error
+     *
+     * @default () => {}
+     */
     afterDiagnostic?: (diagnostics: Diagnostic[]) => void | Promise<void>;
+    /**
+     * Before declaration file be writed hook
+     *
+     * You can transform declaration file-path and content through it
+     *
+     * The file will be skipped when return exact false
+     *
+     * @default () => {}
+     */
     beforeWriteFile?: (filePath: string, content: string) => void | false | TransformWriteFile;
+    /**
+     * After build hook
+     *
+     * It wil be called after all declaration files are written
+     *
+     * @default () => {}
+     */
     afterBuild?: () => void | Promise<void>;
-}
-declare function dtsPlugin(options?: PluginOptions): Plugin;
+}
+
+declare function dtsPlugin(options?: PluginOptions): vite.Plugin;
 
-export { dtsPlugin as default };
+export { PluginOptions, dtsPlugin as default };