vite-plugin-dts 2.3.0 → 3.0.0-beta.2

package/dist/index.mjs

@@ -5,20 +5,16 @@ import __cjs_mod__ from 'module';
 const __filename = __cjs_url__.fileURLToPath(import.meta.url);
 const __dirname = __cjs_path__.dirname(__filename);
 const require = __cjs_mod__.createRequire(import.meta.url);
-import { isAbsolute, resolve as resolve$1, dirname, normalize, sep, relative, basename } from 'node:path';
-import fs from 'fs-extra';
-import os from 'os';
-import { cyan, yellow, red, green } from 'kolorist';
-import glob from 'fast-glob';
-import debug from 'debug';
-import { Project } from 'ts-morph';
-import { normalizePath, createLogger } from 'vite';
-import { createFilter } from '@rollup/pluginutils';
+import { resolve as resolve$1, posix, isAbsolute, dirname, normalize, sep, relative, basename } from 'node:path';
 import { existsSync, readdirSync, lstatSync, rmdirSync } from 'node:fs';
-import typescript from 'typescript';
-import { createRequire } from 'node:module';
-import { parse } from '@babel/parser';
-import MagicString from 'magic-string';
+import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { platform, cpus } from 'node:os';
+import ts from 'typescript';
+import { createFilter } from '@rollup/pluginutils';
+import { createParsedCommandLine } from '@vue/language-core';
+import { createProgram } from 'vue-tsc';
+import debug from 'debug';
+import { cyan, yellow, green } from 'kolorist';
 import { ExtractorConfig, CompilerState } from '@microsoft/api-extractor';
 import { Collector } from '@microsoft/api-extractor/lib/collector/Collector.js';
 import { MessageRouter } from '@microsoft/api-extractor/lib/collector/MessageRouter.js';
@@ -26,6 +22,105 @@ import { SourceMapper } from '@microsoft/api-extractor/lib/collector/SourceMappe
 import { DtsRollupGenerator, DtsRollupKind } from '@microsoft/api-extractor/lib/generators/DtsRollupGenerator.js';
 import { PackageJsonLookup } from '@rushstack/node-core-library';
 
+const dtsRE$1 = /\.d\.tsx?$/;
+function rollupDeclarationFiles({
+  root,
+  compilerOptions,
+  outDir,
+  entryPath,
+  fileName,
+  libFolder,
+  bundledPackages
+}) {
+  const configObjectFullPath = resolve$1(root, "api-extractor.json");
+  const packageJsonLookup = new PackageJsonLookup();
+  const packageJsonFullPath = packageJsonLookup.tryGetPackageJsonFilePathFor(configObjectFullPath);
+  if (!dtsRE$1.test(fileName)) {
+    fileName += ".d.ts";
+  }
+  const extractorConfig = ExtractorConfig.prepare({
+    configObject: {
+      projectFolder: root,
+      mainEntryPointFilePath: entryPath,
+      bundledPackages,
+      compiler: {
+        // tsconfigFilePath: tsConfigPath,
+        overrideTsconfig: {
+          $schema: "http://json.schemastore.org/tsconfig",
+          compilerOptions: {
+            ...compilerOptions,
+            target: "ESNext"
+          }
+        }
+      },
+      apiReport: {
+        enabled: false,
+        reportFileName: "<unscopedPackageName>.api.md"
+      },
+      docModel: {
+        enabled: false
+      },
+      dtsRollup: {
+        enabled: true,
+        publicTrimmedFilePath: resolve$1(outDir, fileName)
+      },
+      tsdocMetadata: {
+        enabled: false
+      },
+      messages: {
+        compilerMessageReporting: {
+          default: {
+            logLevel: "none"
+          }
+        },
+        extractorMessageReporting: {
+          default: {
+            logLevel: "none"
+          }
+        }
+      }
+    },
+    configObjectFullPath,
+    packageJsonFullPath
+  });
+  const compilerState = CompilerState.create(extractorConfig, {
+    localBuild: false,
+    showVerboseMessages: false,
+    typescriptCompilerFolder: libFolder ? resolve$1(libFolder, "..") : void 0
+  });
+  const sourceMapper = new SourceMapper();
+  const messageRouter = new MessageRouter({
+    workingPackageFolder: root,
+    messageCallback: void 0,
+    messagesConfig: extractorConfig.messages,
+    showVerboseMessages: false,
+    showDiagnostics: false,
+    tsdocConfiguration: extractorConfig.tsdocConfiguration,
+    sourceMapper
+  });
+  const collector = new Collector({
+    program: compilerState.program,
+    messageRouter,
+    extractorConfig,
+    sourceMapper
+  });
+  collector.analyze();
+  DtsRollupGenerator.writeTypingsFile(
+    collector,
+    extractorConfig.publicTrimmedFilePath,
+    DtsRollupKind.PublicRelease,
+    extractorConfig.newlineKind
+  );
+}
+
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+const isWindows = platform() === "win32";
+function normalizePath(id) {
+  return posix.normalize(isWindows ? slash(id) : id);
+}
 function isNativeObj(value) {
   return Object.prototype.toString.call(value) === "[object Object]";
 }
@@ -35,39 +130,6 @@ function isRegExp(value) {
 function isPromise(value) {
   return !!value && typeof value.then === "function" && typeof value.catch === "function";
 }
-function mergeObjects(sourceObj, targetObj) {
-  const loop = [
-    {
-      source: sourceObj,
-      target: targetObj
-    }
-  ];
-  while (loop.length) {
-    const { source, target } = loop.pop();
-    Object.keys(target).forEach((key) => {
-      if (isNativeObj(target[key])) {
-        if (!isNativeObj(source[key])) {
-          source[key] = {};
-        }
-        loop.push({
-          source: source[key],
-          target: target[key]
-        });
-      } else if (Array.isArray(target[key])) {
-        if (!Array.isArray(source[key])) {
-          source[key] = [];
-        }
-        loop.push({
-          source: source[key],
-          target: target[key]
-        });
-      } else {
-        source[key] = target[key];
-      }
-    });
-  }
-  return sourceObj;
-}
 function ensureAbsolute(path, root) {
   return path ? isAbsolute(path) ? path : resolve$1(root, path) : root;
 }
@@ -148,25 +210,6 @@ function removeDirIfEmpty(dir) {
   }
   return onlyHasDir;
 }
-function getTsConfig(tsConfigPath, readFileSync) {
-  const tsConfig = {
-    compilerOptions: {},
-    ...typescript.readConfigFile(tsConfigPath, readFileSync).config ?? {}
-  };
-  if (tsConfig.extends) {
-    ensureArray(tsConfig.extends).forEach((configPath) => {
-      const config = getTsConfig(ensureAbsolute(configPath, dirname(tsConfigPath)), readFileSync);
-      Object.assign(tsConfig.compilerOptions, config.compilerOptions);
-      if (!tsConfig.include) {
-        tsConfig.include = config.include;
-      }
-      if (!tsConfig.exclude) {
-        tsConfig.exclude = config.exclude;
-      }
-    });
-  }
-  return tsConfig;
-}
 
 const globSuffixRE = /^((?:.*\.[^.]+)|(?:\*+))$/;
 function normalizeGlob(path) {
@@ -256,456 +299,72 @@ const pureImportRE = /import\s?['"][^;\n]+?['"];?\n?/g;
 function removePureImport(content) {
   return content.replace(pureImportRE, "");
 }
-const setupFunctionRE = /function setup\([\s\S]+\)\s+?\{[\s\S]+return __returned__\n\}/;
-function transferSetupPosition(content) {
-  const match = content.match(setupFunctionRE);
-  if (match) {
-    const setupFunction = match[0];
-    return content.replace(setupFunction, "").replace("setup})", setupFunction.slice("function ".length) + "\n\r})");
-  }
-  return content;
-}
-
-const noScriptContent = "import { defineComponent } from 'vue'\nexport default defineComponent({})";
-const _require = createRequire(import.meta.url);
-let index = 1;
-let compileRoot = null;
-let compiler;
-let vue;
-function requireCompiler() {
-  if (!compiler) {
-    if (compileRoot) {
-      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) {
-      try {
-        compiler = _require("vue/compiler-sfc");
-      } catch (e) {
-        try {
-          compiler = _require("@vue/compiler-sfc");
-        } catch (e2) {
-          throw new Error("@vue/compiler-sfc is not present in the dependency tree.\n");
-        }
-      }
-    }
-  }
-  return compiler;
-}
-function isVue3() {
-  if (!vue) {
-    if (compileRoot) {
-      try {
-        vue = _require(_require.resolve("vue", { paths: [compileRoot] }));
-      } catch (e) {
-      }
-    }
-    if (!vue) {
-      try {
-        vue = _require("vue");
-      } catch (e) {
-        throw new Error("vue is not present in the dependency tree.\n");
-      }
-    }
-  }
-  return vue.version.startsWith("3");
-}
-function setCompileRoot(root) {
-  if (root && root !== compileRoot) {
-    compileRoot = root;
-    compiler = null;
-  }
-}
-function parseCode(code) {
-  const { parse: parseVueCode } = requireCompiler();
-  let descriptor;
-  if (isVue3()) {
-    descriptor = parseVueCode(code).descriptor;
-  } else {
-    descriptor = parseVueCode({ source: code });
-  }
-  return descriptor;
-}
-function transformJsToTs(script) {
-  if (!script)
-    return script;
-  const lang = !script.lang || script.lang === "js" ? "ts" : script.lang === "jsx" ? "tsx" : script.lang;
-  return { ...script, lang };
-}
-function preprocessVueCode(code, setupScript) {
-  const plugins = ["typescript", "decorators-legacy", "jsx"];
-  const scriptAst = parse(code, { sourceType: "module", plugins }).program.body;
-  const source = new MagicString(code);
-  let propsTypeName;
-  let propsTypeLiteral;
-  if (setupScript) {
-    let processDefineProps = function(node) {
-      if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-        if (node.callee.name === "defineProps") {
-          defineProps = node;
-          return true;
-        } else if (node.callee.name === "withDefaults") {
-          const propsDef = node.arguments[0];
-          if (propsDef.type === "CallExpression" && propsDef.callee.type === "Identifier" && propsDef.callee.name === "defineProps") {
-            defineProps = propsDef;
-            return true;
-          }
-        }
-      }
-      return false;
-    };
-    const setupAst = parse(setupScript.content, { sourceType: "module", plugins }).program.body;
-    let defineProps;
-    for (const node of setupAst) {
-      if (node.type === "ExpressionStatement") {
-        processDefineProps(node.expression);
-      } else if (node.type === "VariableDeclaration" && !node.declare) {
-        for (const decl of node.declarations) {
-          if (decl.init && processDefineProps(decl.init)) {
-            break;
-          }
-        }
-      }
-      if (defineProps) {
-        const type = defineProps.typeParameters?.params[0];
-        if (type && type.type === "TSTypeReference" && type.typeName.type === "Identifier") {
-          propsTypeName = type.typeName.name;
-        } else if (type?.type === "TSTypeLiteral") {
-          propsTypeName = "__DTS_Props__";
-          propsTypeLiteral = setupScript.content.substring(type.start, type.end);
-        }
-        break;
-      }
-    }
-  }
-  const declRecord = /* @__PURE__ */ new Map();
-  let defaultExport;
-  let options;
-  for (const node of scriptAst) {
-    if (node.type === "VariableDeclaration") {
-      for (const decl of node.declarations) {
-        if (decl.id.type === "Identifier" && decl.init) {
-          let properties;
-          if (decl.init.type === "ObjectExpression") {
-            properties = decl.init.properties;
-          } else if (decl.init.type === "CallExpression" && decl.init.arguments[0]?.type === "ObjectExpression") {
-            properties = decl.init.arguments[0].properties;
-          }
-          if (!properties)
-            continue;
-          if (defaultExport && decl.id.name === defaultExport) {
-            options = properties;
-            break;
-          } else {
-            declRecord.set(decl.id.name, properties);
-          }
-        }
-      }
-    }
-    if (node.type === "ExportDefaultDeclaration") {
-      if (node.declaration.type === "ObjectExpression") {
-        options = node.declaration.properties;
-      } else if (node.declaration.type === "CallExpression" && node.declaration.arguments[0]?.type === "ObjectExpression") {
-        options = node.declaration.arguments[0].properties;
-      } else if (node.declaration.type === "Identifier") {
-        if (declRecord.has(node.declaration.name)) {
-          options = declRecord.get(node.declaration.name);
-        } else {
-          defaultExport = node.declaration.name;
-        }
-      }
-    }
-    if (options) {
-      for (const option of options) {
-        if (propsTypeName && option.type === "ObjectProperty" && option.key.type === "Identifier" && option.key.name === "props" && option.value.type === "ObjectExpression") {
-          for (const prop of option.value.properties) {
-            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
-              if (prop.value.type === "ObjectExpression") {
-                for (const propDef of prop.value.properties) {
-                  if (propDef.type === "ObjectProperty" && propDef.key.type === "Identifier" && propDef.key.name === "type") {
-                    source.prependLeft(
-                      propDef.end,
-                      ` as unknown as __PropType<${propsTypeName}['${prop.key.name}']>`
-                    );
-                  }
-                }
-              } else {
-                source.prependLeft(
-                  prop.end,
-                  ` as unknown as __PropType<${propsTypeName}['${prop.key.name}']>`
-                );
-              }
-            }
-          }
-        }
-        if (option.type === "ObjectProperty" && option.key.type === "Identifier" && option.key.name === "components") {
-          source.overwrite(option.value.start, option.value.end, "undefined");
-        }
-        if (option.type === "ObjectMethod" && option.key.type === "Identifier" && option.key.name === "setup") {
-          let exposed;
-          let returned;
-          for (const node2 of option.body.body) {
-            if (!exposed && node2.type === "ExpressionStatement" && node2.expression.type === "CallExpression" && node2.expression.callee.type === "Identifier" && node2.expression.callee.name === "expose") {
-              exposed = node2.expression.arguments[0];
-              continue;
-            }
-            if (node2.type === "ReturnStatement") {
-              returned = node2;
-              break;
-            }
-          }
-          const newReturned = exposed && exposed.type === "ObjectExpression" ? `return ${code.substring(exposed.start, exposed.end)}` : setupScript ? "return {}" : "";
-          if (newReturned) {
-            if (returned) {
-              source.overwrite(returned.start, returned.end, newReturned);
-            } else if (option.body.body.length) {
-              source.appendRight(option.body.body.at(-1).end, `
-${newReturned}
-`);
-            }
-          }
-        }
-      }
-      break;
-    }
-  }
-  if (propsTypeName) {
-    if (propsTypeLiteral) {
-      source.prepend(`
-type ${propsTypeName} = ${propsTypeLiteral}
-
-`);
-    }
-    source.prepend("import type { PropType as __PropType } from 'vue'\n");
-  }
-  return source.toString();
-}
-function compileVueCode(code) {
-  const { compileScript, rewriteDefault } = requireCompiler();
-  const descriptor = parseCode(code);
-  const { script, scriptSetup } = descriptor;
-  let error;
-  let content;
-  let ext = "js";
-  if (script || scriptSetup) {
-    const compiled = compileScript(
-      {
-        ...descriptor,
-        script: transformJsToTs(script),
-        scriptSetup: transformJsToTs(scriptSetup),
-        cssVars: []
-      },
-      { id: `${index++}` }
-    );
-    try {
-      content = preprocessVueCode(compiled.content, scriptSetup);
-    } catch (e) {
-      error = e;
-      content = compiled.content;
-    }
-    content = rewriteDefault(content, "_sfc_main", ["typescript", "decorators-legacy"]);
-    if (scriptSetup) {
-      content = transferSetupPosition(content);
-      ext = scriptSetup.lang || "js";
-    } else if (script && script.content) {
-      ext = script.lang || "js";
-    }
-    content += "\nexport default _sfc_main\n";
-  } else {
-    content = noScriptContent;
-    ext = "ts";
-  }
-  return { error, content, ext };
-}
-
-const dtsRE$1 = /\.d\.tsx?$/;
-function rollupDeclarationFiles({
-  root,
-  compilerOptions,
-  outputDir,
-  entryPath,
-  fileName,
-  libFolder,
-  bundledPackages
-}) {
-  const configObjectFullPath = resolve$1(root, "api-extractor.json");
-  const packageJsonLookup = new PackageJsonLookup();
-  const packageJsonFullPath = packageJsonLookup.tryGetPackageJsonFilePathFor(configObjectFullPath);
-  if (!dtsRE$1.test(fileName)) {
-    fileName += ".d.ts";
-  }
-  const extractorConfig = ExtractorConfig.prepare({
-    configObject: {
-      projectFolder: root,
-      mainEntryPointFilePath: entryPath,
-      bundledPackages,
-      compiler: {
-        overrideTsconfig: {
-          $schema: "http://json.schemastore.org/tsconfig",
-          compilerOptions
-        }
-      },
-      apiReport: {
-        enabled: false,
-        reportFileName: "<unscopedPackageName>.api.md"
-      },
-      docModel: {
-        enabled: false
-      },
-      dtsRollup: {
-        enabled: true,
-        publicTrimmedFilePath: resolve$1(outputDir, fileName)
-      },
-      tsdocMetadata: {
-        enabled: false
-      },
-      messages: {
-        compilerMessageReporting: {
-          default: {
-            logLevel: "none"
-          }
-        },
-        extractorMessageReporting: {
-          default: {
-            logLevel: "none"
-          }
-        }
-      }
-    },
-    configObjectFullPath,
-    packageJsonFullPath
-  });
-  const compilerState = CompilerState.create(extractorConfig, {
-    localBuild: false,
-    showVerboseMessages: false,
-    typescriptCompilerFolder: libFolder ? resolve$1(libFolder, "..") : void 0
-  });
-  const sourceMapper = new SourceMapper();
-  const messageRouter = new MessageRouter({
-    workingPackageFolder: root,
-    messageCallback: void 0,
-    messagesConfig: extractorConfig.messages,
-    showVerboseMessages: false,
-    showDiagnostics: false,
-    tsdocConfiguration: extractorConfig.tsdocConfiguration,
-    sourceMapper
-  });
-  const collector = new Collector({
-    program: compilerState.program,
-    messageRouter,
-    extractorConfig,
-    sourceMapper
-  });
-  collector.analyze();
-  DtsRollupGenerator.writeTypingsFile(
-    collector,
-    extractorConfig.publicTrimmedFilePath,
-    DtsRollupKind.PublicRelease,
-    extractorConfig.newlineKind
-  );
-}
 
-const noneExport = "export {};\n";
 const vueRE = /\.vue$/;
-const svelteRE = /\.svelte$/;
 const tsRE = /\.(m|c)?tsx?$/;
-const jsRE = /\.(m|c)?jsx?$/;
 const dtsRE = /\.d\.(m|c)?tsx?$/;
 const tjsRE = /\.(m|c)?(t|j)sx?$/;
 const mtjsRE = /\.m(t|j)sx?$/;
 const ctjsRE = /\.c(t|j)sx?$/;
-const watchExtensionRE = /\.(vue|(m|c)?(t|j)sx?)$/;
 const fullRelativeRE = /^\.\.?\//;
+const watchExtensionRE = /\.(vue|(m|c)?(t|j)sx?)$/;
 const defaultIndex = "index.d.ts";
+const logPrefix = cyan("[vite:dts]");
+const bundleDebug = debug("vite-plugin-dts:bundle");
+const fixedCompilerOptions = {
+  noEmit: false,
+  declaration: true,
+  emitDeclarationOnly: true,
+  noUnusedParameters: false,
+  checkJs: false,
+  skipLibCheck: true,
+  preserveSymlinks: false,
+  noEmitOnError: void 0,
+  target: ts.ScriptTarget.ESNext
+};
 const noop = () => {
 };
 const extPrefix = (file) => mtjsRE.test(file) ? "m" : ctjsRE.test(file) ? "c" : "";
 const resolve = (...paths) => normalizePath(resolve$1(...paths));
-const logPrefix = cyan("[vite:dts]");
-const bundleDebug = debug("vite-plugin-dts:bundle");
 function dtsPlugin(options = {}) {
   const {
-    tsConfigFilePath = "tsconfig.json",
-    aliasesExclude = [],
-    cleanVueFileName = false,
+    tsconfigPath,
     staticImport = false,
     clearPureImport = true,
+    cleanVueFileName = false,
     insertTypesEntry = false,
     rollupTypes = false,
     bundledPackages = [],
-    noEmitOnError = false,
-    skipDiagnostics = false,
+    aliasesExclude = [],
+    logLevel,
     copyDtsFiles = false,
-    logLevel = void 0,
     afterDiagnostic = noop,
     beforeWriteFile = noop,
     afterBuild = noop
   } = options;
-  let compilerOptions = options.compilerOptions ?? {};
-  let root;
+  let root = ensureAbsolute(options.root ?? "", process.cwd());
   let entryRoot = options.entryRoot ?? "";
-  let libName;
-  let indexName;
-  let aliases;
+  let compilerOptions;
+  let rawCompilerOptions;
+  let outDirs;
   let entries;
-  let logger;
-  let project;
-  let tsConfigPath;
-  let outputDirs;
-  let isBundle = false;
   let include;
   let exclude;
+  let aliases;
+  let libName;
+  let indexName;
+  let logger;
+  let host;
+  let program;
   let filter;
-  let libFolderPath = options.libFolderPath;
-  const sourceDtsFiles = /* @__PURE__ */ new Set();
-  const includedFiles = /* @__PURE__ */ new Set();
-  const emittedFiles = /* @__PURE__ */ new Map();
-  let hasJsVue = false;
-  let allowJs = false;
-  let transformError = false;
-  async function internalTransform(id) {
-    if (!project || !filter(id)) {
-      return;
-    }
-    if (vueRE.test(id)) {
-      const { error, content, ext } = compileVueCode(await fs.readFile(id, "utf-8"));
-      if (!transformError && error) {
-        logger.error(
-          red(
-            `
-${cyan(
-              "[vite:dts]"
-            )} A error occurred when transform code, maybe there are some inertnal bugs.
-`
-          )
-        );
-        transformError = true;
-      }
-      if (content) {
-        if (ext === "js" || ext === "jsx")
-          hasJsVue = true;
-        project.createSourceFile(`${id}.${ext || "js"}`, content, { overwrite: true });
-      }
-    } else if (!id.includes(".vue?vue") && (tsRE.test(id) || allowJs && jsRE.test(id))) {
-      project.createSourceFile(id, await fs.readFile(id, "utf-8"), { overwrite: true });
-    } else if (svelteRE.test(id)) {
-      const content = "export { SvelteComponentTyped as default } from 'svelte/internal';";
-      project.createSourceFile(`${id}.ts`, content, { overwrite: true });
-    }
-  }
+  let bundled = false;
+  const rootFiles = /* @__PURE__ */ new Set();
+  const outputFiles = /* @__PURE__ */ new Map();
   return {
     name: "vite:dts",
     apply: "build",
     enforce: "pre",
     config(config) {
-      if (isBundle)
-        return;
       const aliasOptions = config?.resolve?.alias ?? [];
       if (isNativeObj(aliasOptions)) {
         aliases = Object.entries(aliasOptions).map(([key, value]) => {
@@ -722,23 +381,19 @@ ${cyan(
         );
       }
     },
-    configResolved(config) {
-      if (isBundle)
-        return;
-      logger = logLevel ? createLogger(logLevel, { allowClearScreen: config.clearScreen }) : config.logger;
-      if (!config.build.lib) {
-        logger.warn(
-          yellow(
-            `
-${cyan(
-              "[vite:dts]"
-            )} You are building a library that may not need to generate declaration files.
-`
-          )
-        );
-        libName = "_default";
-        indexName = defaultIndex;
-      } else {
+    async configResolved(config) {
+      logger = logLevel ? (await import('vite')).createLogger(logLevel, { allowClearScreen: config.clearScreen }) : config.logger;
+      root = ensureAbsolute(options.root ?? "", config.root);
+      if (config.build.lib) {
+        const input = typeof config.build.lib.entry === "string" ? [config.build.lib.entry] : config.build.lib.entry;
+        if (Array.isArray(input)) {
+          entries = input.reduce((prev, current) => {
+            prev[basename(current)] = current;
+            return prev;
+          }, {});
+        } else {
+          entries = { ...input };
+        }
         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";
@@ -746,199 +401,201 @@ ${cyan(
         if (!dtsRE.test(indexName)) {
           indexName = `${indexName.replace(tjsRE, "")}.d.${extPrefix(indexName)}ts`;
         }
-      }
-      root = ensureAbsolute(options.root ?? "", config.root);
-      tsConfigPath = ensureAbsolute(tsConfigFilePath, root);
-      libFolderPath = libFolderPath && ensureAbsolute(libFolderPath, root);
-      outputDirs = options.outputDir ? ensureArray(options.outputDir).map((d) => ensureAbsolute(d, root)) : [ensureAbsolute(config.build.outDir, root)];
-      if (!outputDirs[0]) {
-        logger.error(
-          red(
+      } else {
+        logger.warn(
+          yellow(
             `
 ${cyan(
               "[vite:dts]"
-            )} Can not resolve declaration directory. Please check your vite config and plugin options.
+            )} You are building a library that may not need to generate declaration files.
 `
           )
         );
-        return;
+        libName = "_default";
+        indexName = defaultIndex;
       }
-      setCompileRoot(root);
-      project = new Project({
-        compilerOptions: mergeObjects(compilerOptions, {
-          rootDir: compilerOptions.rootDir || root,
-          noEmitOnError,
-          outDir: outputDirs[0],
-          declarationDir: void 0,
-          noUnusedParameters: false,
-          declaration: true,
-          noEmit: false,
-          emitDeclarationOnly: true,
-          composite: false
-        }),
-        tsConfigFilePath: tsConfigPath,
-        skipAddingFilesFromTsConfig: true,
-        libFolderPath
-      });
-      allowJs = project.getCompilerOptions().allowJs ?? false;
-      const tsConfig = getTsConfig(tsConfigPath, project.getFileSystem().readFileSync);
-      include = ensureArray(options.include ?? tsConfig.include ?? "**/*").map(normalizeGlob);
-      exclude = ensureArray(options.exclude ?? tsConfig.exclude ?? "node_modules/**").map(
-        normalizeGlob
-      );
-      filter = createFilter(include, exclude, { resolve: root });
-      compilerOptions = tsConfig.compilerOptions;
+      if (!options.outDir) {
+        outDirs = [ensureAbsolute(config.build.outDir, root)];
+      }
+      bundleDebug("parse vite config");
     },
-    async buildStart(inputOptions) {
-      if (Array.isArray(inputOptions.input)) {
-        entries = inputOptions.input.reduce((prev, current) => {
+    options(options2) {
+      if (entries)
+        return;
+      const input = typeof options2.input === "string" ? [options2.input] : options2.input;
+      if (Array.isArray(input)) {
+        entries = input.reduce((prev, current) => {
           prev[basename(current)] = current;
           return prev;
         }, {});
       } else {
-        entries = { ...inputOptions.input };
+        entries = { ...input };
       }
-      bundleDebug("parse entries");
-      sourceDtsFiles.clear();
-      includedFiles.clear();
-      if (project && include && include.length) {
-        const files = await glob(include, {
-          cwd: root,
-          absolute: true,
-          ignore: exclude
-        });
-        for (const file of files) {
-          this.addWatchFile(file);
-          if (dtsRE.test(file)) {
-            sourceDtsFiles.add(project.addSourceFileAtPath(file));
-            if (!copyDtsFiles) {
-              continue;
-            }
-            includedFiles.add(file);
-            continue;
-          }
-          includedFiles.add(`${file.replace(tjsRE, "")}.d.${extPrefix(file)}ts`);
-        }
-        if (hasJsVue) {
-          if (!allowJs) {
-            logger.warn(
-              yellow(
-                `${cyan(
-                  "[vite:dts]"
-                )} Some js files are referenced, but you may not enable the 'allowJs' option.`
-              )
-            );
-          }
-          project.compilerOptions.set({ allowJs: true });
+      logger = logger || console;
+      libName = "_default";
+      indexName = defaultIndex;
+      bundleDebug("parse options");
+    },
+    async buildStart() {
+      if (program)
+        return;
+      bundleDebug("begin buildStart");
+      const configPath = tsconfigPath ? ensureAbsolute(tsconfigPath, root) : ts.findConfigFile(root, ts.sys.fileExists);
+      const content = configPath ? createParsedCommandLine(ts, ts.sys, configPath) : void 0;
+      const config = content ? {
+        include: content.raw.include,
+        exclude: content.raw.exclude,
+        raw: content.raw,
+        options: {
+          ...content.options,
+          ...options.compilerOptions || {},
+          ...fixedCompilerOptions
         }
-        bundleDebug("collect files");
+      } : { options: { ...options.compilerOptions || {}, ...fixedCompilerOptions } };
+      if (!outDirs) {
+        outDirs = options.outDir ? ensureArray(options.outDir).map((d) => ensureAbsolute(d, root)) : [ensureAbsolute(config.raw?.compilerOptions?.outDir || "dist", root)];
+      }
+      include = ensureArray(options.include ?? config.include ?? "**/*").map(normalizeGlob);
+      exclude = ensureArray(options.exclude ?? config.exclude ?? "node_modules/**").map(
+        normalizeGlob
+      );
+      compilerOptions = { ...config.options, outDir: outDirs[0] };
+      rawCompilerOptions = config.raw?.compilerOptions || {};
+      filter = createFilter(include, exclude, { resolve: root });
+      const rootNames = Object.values(entries).concat(content?.fileNames.filter(filter) || []).map(normalizePath);
+      host = ts.createCompilerHost(compilerOptions, true);
+      program = createProgram({ host, rootNames, options: compilerOptions });
+      libName = libName || "_default";
+      indexName = indexName || defaultIndex;
+      const diagnostics = program.getDeclarationDiagnostics();
+      if (diagnostics?.length) {
+        logger.error(ts.formatDiagnostics(diagnostics, host));
       }
+      if (typeof afterDiagnostic === "function") {
+        const result = afterDiagnostic(diagnostics);
+        isPromise(result) && await result;
+      }
+      rootNames.forEach((file) => {
+        this.addWatchFile(file);
+        rootFiles.add(file);
+      });
+      bundleDebug("create ts program");
     },
-    async transform(_, id) {
-      await internalTransform(id);
-      return null;
+    transform(_, id) {
+      if (!program || !filter(id) || id.includes(".vue?vue") || !tsRE.test(id) && !vueRE.test(id)) {
+        return;
+      }
+      id = normalizePath(id);
+      rootFiles.delete(id);
+      let sourceFile = program.getSourceFile(normalizePath(id));
+      if (!sourceFile && vueRE.test(id)) {
+        sourceFile = program.getSourceFile(id + ".ts") || program.getSourceFile(id + ".js") || program.getSourceFile(id + ".tsx") || program.getSourceFile(id + ".jsx");
+      }
+      if (!sourceFile)
+        return;
+      const outDir = outDirs[0];
+      const service = program.__vue.languageService;
+      for (const outputFile of service.getEmitOutput(sourceFile.fileName, true).outputFiles) {
+        outputFiles.set(resolve(root, relative(outDir, outputFile.name)), outputFile.text);
+      }
+      const dtsId = id.replace(tjsRE, ".d.ts");
+      const dtsSourceFile = program.getSourceFile(dtsId);
+      dtsSourceFile && filter(dtsSourceFile.fileName) && outputFiles.set(dtsSourceFile.fileName, dtsSourceFile.getFullText());
     },
-    async watchChange(id) {
-      if (watchExtensionRE.test(id)) {
-        isBundle = false;
-        if (project) {
-          const sourceFile = project.getSourceFile(normalizePath(id));
-          sourceFile && project.removeSourceFile(sourceFile);
-          await internalTransform(id);
+    watchChange(id) {
+      if (host && program && watchExtensionRE.test(id)) {
+        const sourceFile = host.getSourceFile(normalizePath(id), ts.ScriptTarget.ESNext);
+        if (sourceFile && filter(sourceFile.fileName)) {
+          !vueRE.test(id) && rootFiles.add(sourceFile.fileName);
+          program.__vue.projectVersion++;
+          bundled = false;
         }
       }
     },
-    async closeBundle() {
-      if (!outputDirs || !project || isBundle)
+    async writeBundle() {
+      if (!program || bundled)
         return;
+      bundled = true;
+      bundleDebug("begin writeBundle");
       logger.info(green(`
 ${logPrefix} Start generate declaration files...`));
-      bundleDebug("start");
-      isBundle = true;
-      emittedFiles.clear();
       const startTime = Date.now();
-      project.resolveSourceFileDependencies();
-      bundleDebug("resolve");
-      if (!skipDiagnostics) {
-        const diagnostics = project.getPreEmitDiagnostics();
-        if (diagnostics?.length) {
-          logger.warn(project.formatDiagnosticsWithColorAndContext(diagnostics));
+      const outDir = outDirs[0];
+      const emittedFiles = /* @__PURE__ */ new Map();
+      const service = program.__vue.languageService;
+      const sourceFiles = program.getSourceFiles();
+      for (const sourceFile of sourceFiles) {
+        if (!filter(sourceFile.fileName))
+          continue;
+        if (copyDtsFiles && dtsRE.test(sourceFile.fileName)) {
+          outputFiles.set(sourceFile.fileName, sourceFile.getFullText());
         }
-        if (typeof afterDiagnostic === "function") {
-          const result = afterDiagnostic(diagnostics);
-          isPromise(result) && await result;
+        if (rootFiles.has(sourceFile.fileName)) {
+          for (const outputFile of service.getEmitOutput(sourceFile.fileName, true).outputFiles) {
+            outputFiles.set(resolve(root, relative(outDir, outputFile.name)), outputFile.text);
+          }
+          rootFiles.delete(sourceFile.fileName);
         }
-        bundleDebug("diagnostics");
       }
-      const outputDir = outputDirs[0];
-      const dtsOutputFiles = Array.from(sourceDtsFiles).map((sourceFile) => ({
-        path: sourceFile.getFilePath(),
-        content: sourceFile.getFullText()
-      }));
-      const service = project.getLanguageService();
-      const outputFiles = project.getSourceFiles().map(
-        (sourceFile) => service.getEmitOutput(sourceFile, true).getOutputFiles().map((outputFile) => ({
-          path: resolve(root, relative(outputDir, outputFile.compilerObject.name)),
-          content: outputFile.getText()
-        }))
-      ).flat().concat(dtsOutputFiles);
-      bundleDebug("emit");
-      entryRoot = entryRoot || queryPublicPath(outputFiles.map((file) => file.path));
+      bundleDebug("emit output patch");
+      entryRoot = entryRoot || queryPublicPath(Array.from(outputFiles.keys()));
       entryRoot = ensureAbsolute(entryRoot, root);
-      await runParallel(os.cpus().length, outputFiles, async (outputFile) => {
-        let filePath = outputFile.path;
-        let content = outputFile.content;
-        const isMapFile = filePath.endsWith(".map");
-        if (!includedFiles.has(isMapFile ? filePath.slice(0, -4) : filePath) || clearPureImport && content === noneExport) {
-          return;
-        }
-        if (!isMapFile && content && content !== noneExport) {
-          content = clearPureImport ? removePureImport(content) : content;
-          content = transformAliasImport(filePath, content, aliases, aliasesExclude);
-          content = staticImport || rollupTypes ? transformDynamicImport(content) : content;
-        }
-        filePath = resolve(
-          outputDir,
-          relative(entryRoot, cleanVueFileName ? filePath.replace(".vue.d.ts", ".d.ts") : filePath)
-        );
-        content = cleanVueFileName ? content.replace(/['"](.+)\.vue['"]/g, '"$1"') : content;
-        if (typeof beforeWriteFile === "function") {
-          const result = beforeWriteFile(filePath, content);
-          if (result === false)
-            return;
-          if (result && isNativeObj(result)) {
-            filePath = result.filePath || filePath;
-            content = result.content ?? content;
+      await runParallel(
+        cpus().length,
+        Array.from(outputFiles.entries()),
+        async ([path, content]) => {
+          const isMapFile = path.endsWith(".map");
+          if (!isMapFile && content) {
+            content = clearPureImport ? removePureImport(content) : content;
+            content = transformAliasImport(path, content, aliases, aliasesExclude);
+            content = staticImport || rollupTypes ? transformDynamicImport(content) : content;
+          }
+          path = resolve(
+            outDir,
+            relative(entryRoot, cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path)
+          );
+          content = cleanVueFileName ? content.replace(/['"](.+)\.vue['"]/g, '"$1"') : content;
+          if (typeof beforeWriteFile === "function") {
+            const result = beforeWriteFile(path, content);
+            if (result === false)
+              return;
+            if (result && isNativeObj(result)) {
+              path = result.filePath || path;
+              content = result.content ?? content;
+            }
+          }
+          path = normalizePath(path);
+          const dir = dirname(path);
+          if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
           }
+          await writeFile(path, content, "utf-8");
+          emittedFiles.set(path, content);
         }
-        filePath = normalizePath(filePath);
-        await fs.mkdir(dirname(filePath), { recursive: true });
-        await fs.writeFile(filePath, content, "utf-8");
-        emittedFiles.set(filePath, content);
-      });
-      bundleDebug("output");
+      );
+      bundleDebug("write output");
       if (insertTypesEntry || rollupTypes) {
         const pkgPath = resolve(root, "package.json");
-        const pkg = fs.existsSync(pkgPath) ? JSON.parse(await fs.readFile(pkgPath, "utf-8")) : {};
+        const pkg = existsSync(pkgPath) ? JSON.parse(await readFile(pkgPath, "utf-8")) : {};
         const entryNames = Object.keys(entries);
         const types = pkg.types || pkg.typings || pkg.publishConfig?.types || pkg.publishConfig?.typings || (pkg.exports?.["."] || pkg.exports?.["./"])?.types;
         const multiple = entryNames.length > 1;
-        const typesPath = types ? resolve(root, types) : resolve(outputDir, indexName);
+        const typesPath = types ? resolve(root, types) : resolve(outDir, indexName);
         for (const name of entryNames) {
-          let filePath = multiple ? resolve(outputDir, `${name.replace(tsRE, "")}.d.ts`) : typesPath;
-          if (fs.existsSync(filePath))
+          let path = multiple ? resolve(outDir, `${name.replace(tsRE, "")}.d.ts`) : typesPath;
+          if (existsSync(path))
             continue;
           const index = resolve(
-            outputDir,
+            outDir,
             relative(entryRoot, `${entries[name].replace(tsRE, "")}.d.ts`)
           );
-          let fromPath = normalizePath(relative(dirname(filePath), index));
+          let fromPath = normalizePath(relative(dirname(path), index));
           fromPath = fromPath.replace(dtsRE, "");
           fromPath = fullRelativeRE.test(fromPath) ? fromPath : `./${fromPath}`;
           let content = `export * from '${fromPath}'
 `;
-          if (fs.existsSync(index)) {
-            const entryCodes = await fs.readFile(index, "utf-8");
+          if (existsSync(index)) {
+            const entryCodes = await readFile(index, "utf-8");
             if (entryCodes.includes("export default")) {
               content += `import ${libName} from '${fromPath}'
 export default ${libName}
@@ -947,32 +604,41 @@ export default ${libName}
           }
           let result;
           if (typeof beforeWriteFile === "function") {
-            result = beforeWriteFile(filePath, content);
+            result = beforeWriteFile(path, content);
             if (result && isNativeObj(result)) {
-              filePath = result.filePath ?? filePath;
+              path = result.filePath ?? path;
               content = result.content ?? content;
             }
           }
-          filePath = normalizePath(filePath);
+          path = normalizePath(path);
           if (result !== false) {
-            await fs.writeFile(filePath, content, "utf-8");
-            emittedFiles.set(filePath, content);
+            await writeFile(path, content, "utf-8");
+            emittedFiles.set(path, content);
           }
         }
         bundleDebug("insert index");
         if (rollupTypes) {
           logger.info(green(`${logPrefix} Start rollup declaration files...`));
+          let libFolder = resolve(root, "node_modules/typescript");
+          if (!existsSync(libFolder)) {
+            if (root !== entryRoot) {
+              libFolder = resolve(entryRoot, "node_modules/typescript");
+              if (!existsSync(libFolder))
+                libFolder = void 0;
+            }
+            libFolder = void 0;
+          }
           const rollupFiles = /* @__PURE__ */ new Set();
           if (multiple) {
             for (const name of entryNames) {
-              const path = resolve(outputDir, `${name.replace(tsRE, "")}.d.ts`);
+              const path = resolve(outDir, `${name.replace(tsRE, "")}.d.ts`);
               rollupDeclarationFiles({
                 root,
-                compilerOptions,
-                outputDir,
+                compilerOptions: rawCompilerOptions,
+                outDir,
                 entryPath: path,
                 fileName: basename(path),
-                libFolder: libFolderPath,
+                libFolder,
                 bundledPackages
               });
               emittedFiles.delete(path);
@@ -981,41 +647,40 @@ export default ${libName}
           } else {
             rollupDeclarationFiles({
               root,
-              compilerOptions,
-              outputDir,
+              compilerOptions: rawCompilerOptions,
+              outDir,
               entryPath: typesPath,
               fileName: basename(typesPath),
-              libFolder: libFolderPath,
+              libFolder,
               bundledPackages
             });
             emittedFiles.delete(typesPath);
             rollupFiles.add(typesPath);
           }
-          await runParallel(os.cpus().length, Array.from(emittedFiles.keys()), (f) => fs.unlink(f));
-          removeDirIfEmpty(outputDir);
+          await runParallel(cpus().length, Array.from(emittedFiles.keys()), (f) => unlink(f));
+          removeDirIfEmpty(outDir);
           emittedFiles.clear();
           for (const file of rollupFiles) {
-            emittedFiles.set(file, await fs.readFile(file, "utf-8"));
+            emittedFiles.set(file, await readFile(file, "utf-8"));
           }
-          bundleDebug("rollup");
+          bundleDebug("rollup output");
         }
       }
-      if (outputDirs.length > 1) {
-        const dirs = outputDirs.slice(1);
-        await runParallel(
-          os.cpus().length,
-          Array.from(emittedFiles),
-          async ([wroteFile, content]) => {
-            const relativePath = relative(outputDir, wroteFile);
-            await Promise.all(
-              dirs.map(async (dir) => {
-                const filePath = resolve(dir, relativePath);
-                await fs.mkdir(dirname(filePath), { recursive: true });
-                await fs.writeFile(filePath, content, "utf-8");
-              })
-            );
-          }
-        );
+      if (outDirs.length > 1) {
+        const dirs = outDirs.slice(1);
+        await runParallel(cpus().length, Array.from(emittedFiles), async ([wroteFile, content]) => {
+          const relativePath = relative(outDir, wroteFile);
+          await Promise.all(
+            dirs.map(async (dir) => {
+              const path = resolve(dir, relativePath);
+              const dirPath = dirname(path);
+              if (!existsSync(dirPath)) {
+                await mkdir(dirPath, { recursive: true });
+              }
+              await writeFile(path, content, "utf-8");
+            })
+          );
+        });
       }
       if (typeof afterBuild === "function") {
         const result = afterBuild();