rolldown-plugin-dts 0.12.2 → 0.13.0

package/README.md

@@ -32,60 +32,87 @@ You can find an example in [here](./rolldown.config.ts).
 ## Options
 
 ```ts
-interface Options {
+export interface Options {
   /**
-   * The directory where the the plugin will look for the `tsconfig.json` file.
+   * The directory in which the plugin will search for the `tsconfig.json` file.
    */
   cwd?: string
 
   /**
-   * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
+   * Set to `true` if your entry files are `.d.ts` files instead of `.ts` files.
    *
-   * If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
+   * When enabled, the plugin will skip generating a `.d.ts` file for the entry point.
    */
   dtsInput?: boolean
 
   /**
-   * When `true`, the plugin will only emit `.d.ts` files and remove all other chunks.
+   * If `true`, the plugin will emit only `.d.ts` files and remove all other output chunks.
    *
-   * This feature is particularly beneficial when you need to generate `d.ts` files for the CommonJS format as part of a separate build process.
+   * This is especially useful when generating `.d.ts` files for the CommonJS format as part of a separate build step.
    */
   emitDtsOnly?: boolean
 
   /**
    * The path to the `tsconfig.json` file.
    *
-   * When set to `false`, the plugin will ignore any `tsconfig.json` file.
-   * However, `compilerOptions` can still be specified directly in the options.
+   * If set to `false`, the plugin will ignore any `tsconfig.json` file.
+   * You can still specify `compilerOptions` directly in the options.
    *
-   * @default `tsconfig.json`
+   * @default 'tsconfig.json'
    */
   tsconfig?: string | boolean
 
   /**
-   * The `compilerOptions` for the TypeScript compiler.
+   * Pass a raw `tsconfig.json` object directly to the plugin.
    *
-   * @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
+   * @see https://www.typescriptlang.org/tsconfig
+   */
+  tsconfigRaw?: Omit<TsConfigJson, 'compilerOptions'>
+
+  /**
+   * Override the `compilerOptions` specified in `tsconfig.json`.
+   *
+   * @see https://www.typescriptlang.org/tsconfig/#compilerOptions
    */
   compilerOptions?: TsConfigJson.CompilerOptions
 
   /**
-   * When `true`, the plugin will generate `.d.ts` files using Oxc,
-   * which is blazingly faster than `typescript` compiler.
+   * If `true`, the plugin will generate `.d.ts` files using Oxc,
+   * which is significantly faster than the TypeScript compiler.
    *
-   * This option is enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
+   * This option is automatically enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
    */
   isolatedDeclarations?:
     | boolean
     | Omit<IsolatedDeclarationsOptions, 'sourcemap'>
 
   /**
-   * When `true`, the plugin will generate declaration maps for `.d.ts` files.
+   * If `true`, the plugin will generate declaration maps (`.d.ts.map`) for `.d.ts` files.
    */
   sourcemap?: boolean
 
-  /** Resolve external types used in dts files from `node_modules` */
+  /**
+   * Resolve external types used in `.d.ts` files from `node_modules`.
+   */
   resolve?: boolean | (string | RegExp)[]
+
+  /**
+   * If `true`, the plugin will generate `.d.ts` files using `vue-tsc`.
+   */
+  vue?: boolean
+
+  /**
+   * If `true`, the plugin will launch a separate process for `tsc` or `vue-tsc`.
+   * This enables processing multiple projects in parallel.
+   */
+  parallel?: boolean
+
+  /**
+   * If `true`, the plugin will prepare all files listed in `tsconfig.json` for `tsc` or `vue-tsc`.
+   *
+   * This is especially useful when you have a single `tsconfig.json` for multiple projects in a monorepo.
+   */
+  eager?: boolean
 }
 ```
 

package/dist/index.d.ts

@@ -11,81 +11,106 @@ declare function createFakeJsPlugin({
 //#endregion
 //#region src/generate.d.ts
 declare function createGeneratePlugin({
-  compilerOptions,
+  tsconfigRaw,
+  tsconfigDir,
   isolatedDeclarations,
   emitDtsOnly,
-  vue
-}: Pick<OptionsResolved, "compilerOptions" | "isolatedDeclarations" | "emitDtsOnly" | "vue">): Plugin;
+  vue,
+  parallel,
+  eager
+}: Pick<OptionsResolved, "tsconfigRaw" | "tsconfigDir" | "isolatedDeclarations" | "emitDtsOnly" | "vue" | "parallel" | "eager">): Plugin;
 
 //#endregion
 //#region src/index.d.ts
 interface Options {
   /**
-  * The directory where the the plugin will look for the `tsconfig.json` file.
+  * The directory in which the plugin will search for the `tsconfig.json` file.
   */
   cwd?: string;
   /**
-  * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
+  * Set to `true` if your entry files are `.d.ts` files instead of `.ts` files.
   *
-  * If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
+  * When enabled, the plugin will skip generating a `.d.ts` file for the entry point.
   */
   dtsInput?: boolean;
   /**
-  * When `true`, the plugin will only emit `.d.ts` files and remove all other chunks.
+  * If `true`, the plugin will emit only `.d.ts` files and remove all other output chunks.
   *
-  * This feature is particularly beneficial when you need to generate `d.ts` files for the CommonJS format as part of a separate build process.
+  * This is especially useful when generating `.d.ts` files for the CommonJS format as part of a separate build step.
   */
   emitDtsOnly?: boolean;
   /**
   * The path to the `tsconfig.json` file.
   *
-  * When set to `false`, the plugin will ignore any `tsconfig.json` file.
-  * However, `compilerOptions` can still be specified directly in the options.
+  * If set to `false`, the plugin will ignore any `tsconfig.json` file.
+  * You can still specify `compilerOptions` directly in the options.
   *
-  * @default `tsconfig.json`
+  * @default 'tsconfig.json'
   */
   tsconfig?: string | boolean;
   /**
-  * The `compilerOptions` for the TypeScript compiler.
+  * Pass a raw `tsconfig.json` object directly to the plugin.
+  *
+  * @see https://www.typescriptlang.org/tsconfig
+  */
+  tsconfigRaw?: Omit<TsConfigJson, "compilerOptions">;
+  /**
+  * Override the `compilerOptions` specified in `tsconfig.json`.
   *
-  * @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
+  * @see https://www.typescriptlang.org/tsconfig/#compilerOptions
   */
   compilerOptions?: TsConfigJson.CompilerOptions;
   /**
-  * When `true`, the plugin will generate `.d.ts` files using Oxc,
-  * which is blazingly faster than `typescript` compiler.
+  * If `true`, the plugin will generate `.d.ts` files using Oxc,
+  * which is significantly faster than the TypeScript compiler.
   *
-  * This option is enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
+  * This option is automatically enabled when `isolatedDeclarations` in `compilerOptions` is set to `true`.
   */
   isolatedDeclarations?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
   /**
-  * When `true`, the plugin will generate declaration maps for `.d.ts` files.
+  * If `true`, the plugin will generate declaration maps (`.d.ts.map`) for `.d.ts` files.
   */
   sourcemap?: boolean;
-  /** Resolve external types used in dts files from `node_modules` */
+  /**
+  * Resolve external types used in `.d.ts` files from `node_modules`.
+  */
   resolve?: boolean | (string | RegExp)[];
   /**
-  * When `true`, the plugin will generate `.d.ts` via `vue-tsc`.
+  * If `true`, the plugin will generate `.d.ts` files using `vue-tsc`.
   */
   vue?: boolean;
+  /**
+  * If `true`, the plugin will launch a separate process for `tsc` or `vue-tsc`.
+  * This enables processing multiple projects in parallel.
+  */
+  parallel?: boolean;
+  /**
+  * If `true`, the plugin will prepare all files listed in `tsconfig.json` for `tsc` or `vue-tsc`.
+  *
+  * This is especially useful when you have a single `tsconfig.json` for multiple projects in a monorepo.
+  */
+  eager?: boolean;
 }
 type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
-type OptionsResolved = Overwrite<Required<Options>, {
+type OptionsResolved = Overwrite<Required<Omit<Options, "compilerOptions">>, {
   tsconfig: string | undefined;
   isolatedDeclarations: IsolatedDeclarationsOptions | false;
+  tsconfigRaw: TsConfigJson;
+  tsconfigDir: string;
 }>;
 declare function dts(options?: Options): Plugin[];
 declare function resolveOptions({
   cwd,
   tsconfig,
   compilerOptions,
+  tsconfigRaw: overriddenTsconfigRaw,
   isolatedDeclarations,
   sourcemap,
   dtsInput,
   emitDtsOnly,
   resolve,
-  vue
-}: Options): OptionsResolved;
-
-//#endregion
+  vue,
+  parallel,
+  eager
+}: Options): OptionsResolved; //#endregion
 export { Options, OptionsResolved, createFakeJsPlugin, createGeneratePlugin, dts, resolveOptions };

package/dist/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
 import Debug from "debug";
@@ -7,6 +6,8 @@ import _generate from "@babel/generator";
 import { parse } from "@babel/parser";
 import * as t from "@babel/types";
 import { isDeclarationType, isTypeOf } from "ast-kit";
+import { fork } from "node:child_process";
+import { createBirpc } from "birpc";
 import { ResolverFactory, isolatedDeclaration } from "rolldown/experimental";
 import { createResolver } from "dts-resolver";
 
@@ -297,7 +298,6 @@ function createFakeJsPlugin({ dtsInput, sourcemap }) {
 			const isDecl = isTypeOf(stmt, ["ExportNamedDeclaration", "ExportDefaultDeclaration"]) && stmt.declaration;
 			const decl = isDecl ? stmt.declaration : stmt;
 			const setDecl = isDecl ? (node) => stmt.declaration = node : setStmt;
-			if (decl.type === "VariableDeclaration" && decl.declarations.length !== 1) throw new Error("Only one declaration is supported");
 			if (decl.type !== "TSDeclareFunction" && !isDeclarationType(decl)) continue;
 			if (isTypeOf(decl, [
 				"TSEnumDeclaration",
@@ -307,12 +307,17 @@ function createFakeJsPlugin({ dtsInput, sourcemap }) {
 				"TSModuleDeclaration",
 				"VariableDeclaration"
 			])) decl.declare = true;
-			let binding = decl.type === "VariableDeclaration" ? decl.declarations[0].id : "id" in decl ? decl.id : null;
-			if (!binding) {
-				binding = t.identifier("export_default");
+			const bindings = [];
+			if (decl.type === "VariableDeclaration") bindings.push(...decl.declarations.map((decl$1) => decl$1.id));
+			else if ("id" in decl && decl.id) {
+				let binding = decl.id;
+				binding = sideEffect ? t.identifier(`_${identifierIdx++}`) : binding;
+				bindings.push(binding);
+			} else {
+				const binding = t.identifier("export_default");
+				bindings.push(binding);
 				decl.id = binding;
 			}
-			binding = sideEffect ? t.identifier(`_${identifierIdx++}`) : binding;
 			const deps = collectDependencies(decl, namespaceStmts);
 			const elements = [
 				t.numericLiteral(0),
@@ -328,7 +333,7 @@ function createFakeJsPlugin({ dtsInput, sourcemap }) {
 			const symbolId = registerSymbol({
 				decl,
 				deps,
-				binding
+				bindings
 			});
 			elements[0] = t.numericLiteral(symbolId);
 			const runtimeAssignment = {
@@ -337,14 +342,20 @@ function createFakeJsPlugin({ dtsInput, sourcemap }) {
 				declarations: [{
 					type: "VariableDeclarator",
 					id: {
-						...binding,
+						...bindings[0],
 						typeAnnotation: null
 					},
 					init: runtime
-				}]
+				}, ...bindings.slice(1).map((binding) => ({
+					type: "VariableDeclarator",
+					id: {
+						...binding,
+						typeAnnotation: null
+					}
+				}))]
 			};
 			if (isDefaultExport) {
-				appendStmts.push(t.exportNamedDeclaration(null, [t.exportSpecifier(binding, t.identifier("default"))]));
+				appendStmts.push(t.exportNamedDeclaration(null, [t.exportSpecifier(bindings[0], t.identifier("default"))]));
 				setStmt(runtimeAssignment);
 			} else setDecl(runtimeAssignment);
 		}
@@ -367,18 +378,20 @@ function createFakeJsPlugin({ dtsInput, sourcemap }) {
 		program.body = patchTsNamespace(program.body);
 		program.body = program.body.map((node) => {
 			if (patchImportSource(node)) return node;
-			if (node.type !== "VariableDeclaration" || node.declarations.length !== 1) return node;
+			if (node.type !== "VariableDeclaration") return node;
 			const [decl] = node.declarations;
 			if (decl.init?.type !== "ArrayExpression" || !decl.init.elements[0]) return null;
 			const [symbolIdNode, ...depsFns] = decl.init.elements;
 			if (symbolIdNode?.type !== "NumericLiteral") return null;
 			const symbolId = symbolIdNode.value;
 			const original = getSymbol(symbolId);
-			const transformedBinding = {
-				...decl.id,
-				typeAnnotation: original.binding.typeAnnotation
-			};
-			overwriteNode(original.binding, transformedBinding);
+			for (const [i, decl$1] of node.declarations.entries()) {
+				const transformedBinding = {
+					...decl$1.id,
+					typeAnnotation: original.bindings[i].typeAnnotation
+				};
+				overwriteNode(original.bindings[i], transformedBinding);
+			}
 			const transformedDeps = depsFns.filter((node$1) => node$1?.type === "ArrowFunctionExpression").map((node$1) => node$1.body);
 			if (original.deps.length) for (let i = 0; i < original.deps.length; i++) {
 				const originalDep = original.deps[i];
@@ -616,153 +629,11 @@ function inheritNodeComments(oldNode, newNode) {
 	}
 }
 
-//#endregion
-//#region src/utils/vue.ts
-const debug$3 = Debug("rolldown-plugin-dts:vue");
-let createVueProgram;
-const require = createRequire(import.meta.url);
-function loadVueLanguageTools() {
-	try {
-		const vueTscPath = require.resolve("vue-tsc");
-		const { proxyCreateProgram } = require(require.resolve("@volar/typescript", { paths: [vueTscPath] }));
-		const vue = require(require.resolve("@vue/language-core", { paths: [vueTscPath] }));
-		return {
-			proxyCreateProgram,
-			vue
-		};
-	} catch (error) {
-		debug$3("vue language tools not found", error);
-		throw new Error("Failed to load vue language tools. Please manually install vue-tsc.");
-	}
-}
-function createVueProgramFactory() {
-	if (createVueProgram) return createVueProgram;
-	debug$3("loading vue language tools");
-	const { proxyCreateProgram, vue } = loadVueLanguageTools();
-	return createVueProgram = proxyCreateProgram(ts, ts.createProgram, (ts$1, options) => {
-		const { configFilePath } = options.options;
-		const vueOptions = typeof configFilePath === "string" ? vue.createParsedCommandLine(ts$1, ts$1.sys, configFilePath.replaceAll("\\", "/")).vueOptions : vue.getDefaultCompilerOptions();
-		const vueLanguagePlugin = vue.createVueLanguagePlugin(ts$1, options.options, vueOptions, (id) => id);
-		return { languagePlugins: [vueLanguagePlugin] };
-	});
-}
-
-//#endregion
-//#region src/utils/tsc.ts
-const debug$2 = Debug("rolldown-plugin-dts:tsc");
-let ts;
-let formatHost;
-function initTs() {
-	debug$2("loading typescript");
-	const require$1 = createRequire(import.meta.url);
-	ts = require$1("typescript");
-	formatHost = {
-		getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-		getNewLine: () => ts.sys.newLine,
-		getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
-	};
-	debug$2(`loaded typescript: ${ts.version}`);
-}
-const defaultCompilerOptions = {
-	declaration: true,
-	noEmit: false,
-	emitDeclarationOnly: true,
-	noEmitOnError: true,
-	checkJs: false,
-	declarationMap: false,
-	skipLibCheck: true,
-	target: 99,
-	resolveJsonModule: true
-};
-function createOrGetTsModule(programs, compilerOptions, id, isEntry, dtsMap, vue) {
-	const program = programs.find((program$1) => {
-		if (isEntry) return program$1.getRootFileNames().includes(id);
-		return program$1.getSourceFile(id);
-	});
-	if (program) {
-		const sourceFile = program.getSourceFile(id);
-		if (sourceFile) return {
-			program,
-			file: sourceFile
-		};
-	}
-	debug$2(`create program for module: ${id}`);
-	const module = createTsProgram(compilerOptions, dtsMap, id, vue);
-	debug$2(`created program for module: ${id}`);
-	programs.push(module.program);
-	return module;
-}
-function createTsProgram(compilerOptions, dtsMap, id, vue) {
-	const overrideCompilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, ".").options;
-	const options = {
-		...defaultCompilerOptions,
-		...overrideCompilerOptions
-	};
-	const host = ts.createCompilerHost(options, true);
-	const { readFile: _readFile, fileExists: _fileExists } = host;
-	host.fileExists = (fileName) => {
-		const module = getTsModule(dtsMap, fileName);
-		if (module) return true;
-		if (debug$2.enabled && !RE_NODE_MODULES.test(fileName)) debug$2(`file exists from fs: ${fileName}`);
-		return _fileExists(fileName);
-	};
-	host.readFile = (fileName) => {
-		const module = getTsModule(dtsMap, fileName);
-		if (module) return module.code;
-		if (debug$2.enabled && !RE_NODE_MODULES.test(fileName)) debug$2(`read file from fs: ${fileName}`);
-		return _readFile(fileName);
-	};
-	const entries = [...new Set([...Array.from(dtsMap.values()).filter((v) => v.isEntry).map((v) => v.id), id])];
-	const createProgram = vue ? createVueProgramFactory() : ts.createProgram;
-	const program = createProgram({
-		rootNames: entries,
-		options,
-		host
-	});
-	const sourceFile = program.getSourceFile(id);
-	if (!sourceFile) throw new Error(`Source file not found: ${id}`);
-	return {
-		program,
-		file: sourceFile
-	};
-}
-function tscEmit(module) {
-	const { program, file } = module;
-	let dtsCode;
-	let map;
-	const { emitSkipped, diagnostics } = program.emit(
-		file,
-		(fileName, code) => {
-			if (fileName.endsWith(".map")) {
-				debug$2(`emit dts sourcemap: ${fileName}`);
-				map = JSON.parse(code);
-			} else {
-				debug$2(`emit dts: ${fileName}`);
-				dtsCode = code;
-			}
-		},
-		void 0,
-		true,
-		void 0,
-		// @ts-expect-error private API: forceDtsEmit
-		true
-);
-	if (emitSkipped && diagnostics.length) return { error: ts.formatDiagnostics(diagnostics, formatHost) };
-	return {
-		code: dtsCode,
-		map
-	};
-}
-function getTsModule(dtsMap, tsId) {
-	const module = Array.from(dtsMap.values()).find((dts$1) => dts$1.id === tsId);
-	if (!module) return;
-	return module;
-}
-
 //#endregion
 //#region src/generate.ts
 const debug$1 = Debug("rolldown-plugin-dts:generate");
-function createGeneratePlugin({ compilerOptions = {}, isolatedDeclarations, emitDtsOnly = false, vue }) {
+const WORKER_URL = "./utils/tsc-worker.js";
+function createGeneratePlugin({ tsconfigRaw, tsconfigDir, isolatedDeclarations, emitDtsOnly, vue, parallel, eager }) {
 	const dtsMap = new Map();
 	/**
 	* A map of input id to output file name
@@ -774,14 +645,20 @@ function createGeneratePlugin({ compilerOptions = {}, isolatedDeclarations, emit
 	* ])
 	*/
 	const inputAliasMap = new Map();
-	let programs = [];
-	if (vue || !isolatedDeclarations) {
-		initTs();
-		if (vue) createVueProgramFactory();
+	let childProcess;
+	let rpc;
+	let tscEmit;
+	if (parallel) {
+		childProcess = fork(new URL(WORKER_URL, import.meta.url), { stdio: "inherit" });
+		rpc = createBirpc({}, {
+			post: (data) => childProcess.send(data),
+			on: (fn) => childProcess.on("message", fn)
+		});
 	}
 	return {
 		name: "rolldown-plugin-dts:generate",
 		async buildStart(options) {
+			if (!parallel && (!isolatedDeclarations || vue)) ({tscEmit} = await import("./tsc-CeRgkVKp.js"));
 			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
 				debug$1("resolving input alias %s -> %s", name, id);
 				let resolved = await this.resolve(id);
@@ -839,7 +716,7 @@ function createGeneratePlugin({ compilerOptions = {}, isolatedDeclarations, emit
 				include: [RE_DTS],
 				exclude: [RE_NODE_MODULES]
 			} },
-			handler(dtsId) {
+			async handler(dtsId) {
 				if (!dtsMap.has(dtsId)) return;
 				const { code, id, isEntry } = dtsMap.get(dtsId);
 				let dtsCode;
@@ -860,8 +737,18 @@ function createGeneratePlugin({ compilerOptions = {}, isolatedDeclarations, emit
 						map.sourcesContent = void 0;
 					}
 				} else {
-					const module = createOrGetTsModule(programs, compilerOptions, id, isEntry, dtsMap, vue);
-					const result = tscEmit(module);
+					const entries = eager ? void 0 : Array.from(dtsMap.values()).filter((v) => v.isEntry).map((v) => v.id);
+					const options = {
+						tsconfigRaw,
+						tsconfigDir,
+						entries,
+						id,
+						isEntry,
+						vue
+					};
+					let result;
+					if (parallel) result = await rpc.tscEmit(options);
+					else result = tscEmit(options);
 					if (result.error) return this.error(result.error);
 					dtsCode = result.code;
 					map = result.map;
@@ -877,7 +764,7 @@ function createGeneratePlugin({ compilerOptions = {}, isolatedDeclarations, emit
 			for (const fileName of Object.keys(bundle)) if (bundle[fileName].type === "chunk" && !RE_DTS.test(fileName) && !RE_DTS_MAP.test(fileName)) delete bundle[fileName];
 		} : void 0,
 		buildEnd() {
-			programs = [];
+			childProcess?.kill();
 		}
 	};
 }
@@ -942,24 +829,28 @@ function dts(options = {}) {
 	plugins.push(createDtsResolvePlugin(resolved), createFakeJsPlugin(resolved));
 	return plugins;
 }
-function resolveOptions({ cwd = process.cwd(), tsconfig, compilerOptions = {}, isolatedDeclarations, sourcemap, dtsInput = false, emitDtsOnly = false, resolve = false, vue = false }) {
+function resolveOptions({ cwd = process.cwd(), tsconfig, compilerOptions = {}, tsconfigRaw: overriddenTsconfigRaw = {}, isolatedDeclarations, sourcemap, dtsInput = false, emitDtsOnly = false, resolve = false, vue = false, parallel = false, eager = false }) {
+	let resolvedTsconfig;
 	if (tsconfig === true || tsconfig == null) {
 		const { config, path: path$1 } = getTsconfig(cwd) || {};
 		tsconfig = path$1;
-		compilerOptions = {
-			...config?.compilerOptions,
-			...compilerOptions
-		};
+		resolvedTsconfig = config;
 	} else if (typeof tsconfig === "string") {
 		tsconfig = path.resolve(cwd || process.cwd(), tsconfig);
-		const config = parseTsconfig(tsconfig);
-		compilerOptions = {
-			...config.compilerOptions,
-			...compilerOptions
-		};
+		resolvedTsconfig = parseTsconfig(tsconfig);
 	} else tsconfig = void 0;
+	compilerOptions = {
+		...resolvedTsconfig?.compilerOptions,
+		...compilerOptions
+	};
 	sourcemap ??= !!compilerOptions.declarationMap;
 	compilerOptions.declarationMap = sourcemap;
+	const tsconfigRaw = {
+		...resolvedTsconfig,
+		...overriddenTsconfigRaw,
+		compilerOptions
+	};
+	const tsconfigDir = tsconfig ? path.dirname(tsconfig) : cwd;
 	if (isolatedDeclarations == null) isolatedDeclarations = !!compilerOptions?.isolatedDeclarations;
 	if (isolatedDeclarations === true) isolatedDeclarations = {};
 	if (isolatedDeclarations) {
@@ -969,13 +860,16 @@ function resolveOptions({ cwd = process.cwd(), tsconfig, compilerOptions = {}, i
 	return {
 		cwd,
 		tsconfig,
-		compilerOptions,
+		tsconfigDir,
+		tsconfigRaw,
 		isolatedDeclarations,
 		sourcemap,
 		dtsInput,
 		emitDtsOnly,
 		resolve,
-		vue
+		vue,
+		parallel,
+		eager
 	};
 }
 

package/dist/tsc-CeRgkVKp.js

@@ -0,0 +1,3 @@
+import { tscEmit } from "./tsc-H_wSbW_C.js";
+
+export { tscEmit };

package/dist/tsc-H_wSbW_C.js

@@ -0,0 +1,128 @@
+import { createRequire } from "node:module";
+import Debug from "debug";
+import ts from "typescript";
+
+//#region src/utils/vue.ts
+const debug$1 = Debug("rolldown-plugin-dts:vue");
+let createVueProgram;
+const require = createRequire(import.meta.url);
+function loadVueLanguageTools() {
+	try {
+		const vueTscPath = require.resolve("vue-tsc");
+		const { proxyCreateProgram } = require(require.resolve("@volar/typescript", { paths: [vueTscPath] }));
+		const vue = require(require.resolve("@vue/language-core", { paths: [vueTscPath] }));
+		return {
+			proxyCreateProgram,
+			vue
+		};
+	} catch (error) {
+		debug$1("vue language tools not found", error);
+		throw new Error("Failed to load vue language tools. Please manually install vue-tsc.");
+	}
+}
+function createVueProgramFactory(ts$1) {
+	if (createVueProgram) return createVueProgram;
+	debug$1("loading vue language tools");
+	const { proxyCreateProgram, vue } = loadVueLanguageTools();
+	return createVueProgram = proxyCreateProgram(ts$1, ts$1.createProgram, (ts$2, options) => {
+		const { configFilePath } = options.options;
+		const vueOptions = typeof configFilePath === "string" ? vue.createParsedCommandLine(ts$2, ts$2.sys, configFilePath.replaceAll("\\", "/")).vueOptions : vue.getDefaultCompilerOptions();
+		const vueLanguagePlugin = vue.createVueLanguagePlugin(ts$2, options.options, vueOptions, (id) => id);
+		return { languagePlugins: [vueLanguagePlugin] };
+	});
+}
+
+//#endregion
+//#region src/utils/tsc.ts
+const debug = Debug("rolldown-plugin-dts:tsc");
+debug(`loaded typescript: ${ts.version}`);
+const programs = [];
+const formatHost = {
+	getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+	getNewLine: () => ts.sys.newLine,
+	getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+};
+const defaultCompilerOptions = {
+	declaration: true,
+	noEmit: false,
+	emitDeclarationOnly: true,
+	noEmitOnError: true,
+	checkJs: false,
+	declarationMap: false,
+	skipLibCheck: true,
+	target: 99,
+	resolveJsonModule: true,
+	moduleResolution: ts.ModuleResolutionKind.Bundler
+};
+function createOrGetTsModule(options) {
+	const { id, isEntry } = options;
+	const program = programs.find((program$1) => {
+		if (isEntry) return program$1.getRootFileNames().includes(id);
+		return program$1.getSourceFile(id);
+	});
+	if (program) {
+		const sourceFile = program.getSourceFile(id);
+		if (sourceFile) return {
+			program,
+			file: sourceFile
+		};
+	}
+	debug(`create program for module: ${id}`);
+	const module = createTsProgram(options);
+	debug(`created program for module: ${id}`);
+	programs.push(module.program);
+	return module;
+}
+function createTsProgram({ entries, id, tsconfigRaw, tsconfigDir, vue }) {
+	const parsedCmd = ts.parseJsonConfigFileContent(tsconfigRaw, ts.sys, tsconfigDir);
+	const compilerOptions = {
+		...defaultCompilerOptions,
+		...parsedCmd.options
+	};
+	const rootNames = entries ? [...new Set([id, ...entries])] : parsedCmd.fileNames;
+	const host = ts.createCompilerHost(compilerOptions, true);
+	const createProgram = vue ? createVueProgramFactory(ts) : ts.createProgram;
+	const program = createProgram({
+		rootNames,
+		options: compilerOptions,
+		host,
+		projectReferences: parsedCmd.projectReferences
+	});
+	const sourceFile = program.getSourceFile(id);
+	if (!sourceFile) throw new Error(`Source file not found: ${id}`);
+	return {
+		program,
+		file: sourceFile
+	};
+}
+function tscEmit(tscOptions) {
+	const module = createOrGetTsModule(tscOptions);
+	const { program, file } = module;
+	let dtsCode;
+	let map;
+	const { emitSkipped, diagnostics } = program.emit(
+		file,
+		(fileName, code) => {
+			if (fileName.endsWith(".map")) {
+				debug(`emit dts sourcemap: ${fileName}`);
+				map = JSON.parse(code);
+			} else {
+				debug(`emit dts: ${fileName}`);
+				dtsCode = code;
+			}
+		},
+		void 0,
+		true,
+		void 0,
+		// @ts-expect-error private API: forceDtsEmit
+		true
+);
+	if (emitSkipped && diagnostics.length) return { error: ts.formatDiagnostics(diagnostics, formatHost) };
+	return {
+		code: dtsCode,
+		map
+	};
+}
+
+//#endregion
+export { tscEmit };

package/dist/utils/tsc-worker.d.ts

@@ -0,0 +1,27 @@
+import { TsConfigJson } from "get-tsconfig";
+import ts from "typescript";
+
+//#region src/utils/tsc.d.ts
+
+interface TscOptions {
+  tsconfigRaw: TsConfigJson;
+  tsconfigDir: string;
+  entries?: string[];
+  id: string;
+  isEntry: boolean;
+  vue?: boolean;
+}
+interface TscResult {
+  code?: string;
+  map?: any;
+  error?: string;
+}
+declare function tscEmit(tscOptions: TscOptions): TscResult; //#endregion
+//#region src/utils/tsc-worker.d.ts
+declare const functions: {
+  tscEmit: typeof tscEmit;
+};
+type TscFunctions = typeof functions;
+
+//#endregion
+export { TscFunctions };

package/dist/utils/tsc-worker.js

@@ -0,0 +1,12 @@
+import { tscEmit } from "../tsc-H_wSbW_C.js";
+import process from "node:process";
+import { createBirpc } from "birpc";
+
+//#region src/utils/tsc-worker.ts
+const functions = { tscEmit };
+createBirpc(functions, {
+	post: (data) => process.send(data),
+	on: (fn) => process.on("message", fn)
+});
+
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "A Rolldown plugin to bundle dts files",
   "type": "module",
   "license": "MIT",
@@ -45,6 +45,7 @@
     "@babel/parser": "^7.27.2",
     "@babel/types": "^7.27.1",
     "ast-kit": "^2.0.0",
+    "birpc": "^2.3.0",
     "debug": "^4.4.1",
     "dts-resolver": "^2.0.1",
     "get-tsconfig": "^4.10.0"