rolldown-plugin-dts 0.25.0 → 0.25.1

package/README.md

@@ -34,6 +34,20 @@ export default {
 
 You can find an example in [here](./rolldown.config.ts).
 
+### Vite
+
+When using this plugin with Vite, exclude declaration files from Oxc
+transformation to avoid processing generated outputs. Since `oxc.exclude`
+overrides the default exclude list, include JavaScript files as well:
+
+```ts
+dts({
+  oxc: {
+    exclude: [/\.js$/, /\.d\.[cm]?ts$/],
+  },
+})
+```
+
 ## Options
 
 Configuration options for the plugin.
@@ -109,6 +123,8 @@ Determines how the default export is emitted.
 If set to `true`, and you are only exporting a single item using `export default ...`,
 the output will use `export = ...` instead of the standard ES module syntax.
 This is useful for compatibility with CommonJS.
+This option only controls the output format and does not enable support for
+CommonJS-style `.d.ts` input.
 
 #### `sideEffects`
 
@@ -236,6 +252,11 @@ However, this functionality is limited to ESM output format. Consequently,
 and its corresponding type definition files (`.d.cts`).
 In such cases, the `emitDtsOnly` option can be particularly helpful.
 
+The plugin expects ESM-style `.d.ts` input. CommonJS-style declaration syntax
+such as `export =` or `import x = require("x")` will produce a warning and is
+not guaranteed to bundle correctly. If this syntax comes from a dependency in
+`node_modules`, mark that dependency as external in your Rolldown config.
+
 ## Credits
 
 The project is inspired by [rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts)

package/dist/index.d.mts

@@ -74,6 +74,8 @@ interface GeneralOptions {
   * If set to `true`, and you are only exporting a single item using `export default ...`,
   * the output will use `export = ...` instead of the standard ES module syntax.
   * This is useful for compatibility with CommonJS.
+  * This only controls the output format and does not enable support for
+  * CommonJS-style `.d.ts` input.
   */
   cjsDefault?: boolean;
   /**

package/dist/index.mjs

@@ -5,7 +5,7 @@ import { importerId, include } from "rolldown/filter";
 import { generate } from "@babel/generator";
 import { isIdentifierName } from "@babel/helper-validator-identifier";
 import { parse } from "@babel/parser";
-import { isDeclarationType, isIdentifierOf, isTypeOf, resolveString, walkAST } from "ast-kit";
+import { isDeclarationType, isIdentifierOf, isTypeOf, resolveString, walkAST, walkASTAsync } from "ast-kit";
 import { fork, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
@@ -54,7 +54,8 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	let declarationIdx = 0;
 	const declarationMap = /* @__PURE__ */ new Map();
 	const commentsMap = /* @__PURE__ */ new Map();
-	const typeOnlyMap = /* @__PURE__ */ new Map();
+	const moduleExportsMap = /* @__PURE__ */ new Map();
+	const warnedCjsDtsInputs = /* @__PURE__ */ new Set();
 	return {
 		name: "rolldown-plugin-dts:fake-js",
 		outputOptions(options) {
@@ -92,7 +93,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			}
 		}
 	};
-	function transform(code, id) {
+	async function transform(code, id) {
 		let file;
 		try {
 			file = parse(code, {
@@ -105,8 +106,12 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
 		}
 		const { program, comments } = file;
-		const typeOnlyIds = [];
+		moduleExportsMap.set(id, await collectModuleExports(this, program.body, id));
 		const identifierMap = Object.create(null);
+		if (!warnedCjsDtsInputs.has(id) && program.body.some(isCjsDtsInputSyntax)) {
+			warnedCjsDtsInputs.add(id);
+			this.warn(RE_NODE_MODULES.test(id) ? `${id} uses CommonJS dts syntax. CommonJS dts modules cannot be reliably bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `${id} uses CommonJS dts syntax. rolldown-plugin-dts does not support reliably bundling CommonJS dts input.`);
+		}
 		if (comments) {
 			const directives = collectReferenceDirectives(comments);
 			commentsMap.set(id, directives);
@@ -115,7 +120,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		const namespaceStmts = /* @__PURE__ */ new Map();
 		for (const [i, stmt] of program.body.entries()) {
 			const setStmt = (stmt) => program.body[i] = stmt;
-			if (rewriteImportExport(stmt, setStmt, typeOnlyIds)) continue;
+			if (rewriteImportExport(stmt, setStmt)) continue;
 			const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
 			if (sideEffect && stmt.id.type === "StringLiteral" && stmt.id.value[0] === ".") this.warn(`\`declare module ${JSON.stringify(stmt.id.value)}\` will be kept as-is in the output. Relative module declaration may cause unexpected issues. Found in ${id}.`);
 			if (sideEffect && id.endsWith(".vue.d.ts") && code.slice(stmt.start, stmt.end).includes("__VLS_")) continue;
@@ -153,7 +158,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			}
 			const params = collectParams(decl);
 			const childrenSet = /* @__PURE__ */ new Set();
-			const deps = collectDependencies(decl, namespaceStmts, childrenSet, identifierMap);
+			const deps = await collectDependencies(this, decl, id, namespaceStmts, childrenSet, identifierMap);
 			const children = Array.from(childrenSet).filter((child) => bindings.every((b) => child !== b));
 			if (decl !== stmt) decl.leadingComments = stmt.leadingComments;
 			const declarationIdNode = {
@@ -256,7 +261,6 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			...program.body,
 			...appendStmts
 		];
-		typeOnlyMap.set(id, typeOnlyIds);
 		const result = generate(file, {
 			comments: false,
 			sourceMaps: sourcemap,
@@ -269,11 +273,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	}
 	function renderChunk(code, chunk) {
 		if (!RE_DTS.test(chunk.fileName)) return;
-		const typeOnlyIds = [];
-		for (const module of chunk.moduleIds) {
-			const ids = typeOnlyMap.get(module);
-			if (ids) typeOnlyIds.push(...ids);
-		}
+		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
 		let file;
 		try {
 			file = parse(code, { sourceType: "module" });
@@ -286,7 +286,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		program.body = program.body.map((node) => {
 			if (isHelperImport(node)) return null;
 			if (node.type === "ExpressionStatement") return null;
-			const newNode = patchImportExport(node, typeOnlyIds, cjsDefault);
+			const newNode = patchImportExport(node, exportInfo, cjsDefault);
 			if (newNode || newNode === false) return newNode;
 			if (node.type !== "VariableDeclaration") return node;
 			if (!isRuntimeBindingVariableDeclaration(node)) return null;
@@ -354,10 +354,6 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			map: result.map
 		};
 	}
-	function getIdentifierIndex(identifierMap, name) {
-		if (name in identifierMap) return ++identifierMap[name];
-		return identifierMap[name] = 0;
-	}
 	function registerDeclaration(info) {
 		const declarationId = declarationIdx++;
 		declarationMap.set(declarationId, info);
@@ -366,141 +362,288 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	function getDeclaration(declarationId) {
 		return declarationMap.get(declarationId);
 	}
-	/**
-	* Collects all TSTypeParameter nodes from the given node and groups them by
-	* their name. One name can associate with one or more type parameters. These
-	* names will be used as the parameter name in the generated JavaScript
-	* dependency function.
-	*/
-	function collectParams(node) {
-		const typeParams = [];
-		walkAST(node, { leave(node) {
-			if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => typeof name === "string" ? {
-				type: "Identifier",
-				name
-			} : name));
-		} });
-		const paramMap = /* @__PURE__ */ new Map();
-		for (const typeParam of typeParams) {
-			const name = typeParam.name;
-			const group = paramMap.get(name);
-			if (group) group.push(typeParam);
-			else paramMap.set(name, [typeParam]);
+}
+async function collectModuleExports(context, nodes, id) {
+	const info = {
+		typeOnlyLocals: /* @__PURE__ */ new Set(),
+		exports: /* @__PURE__ */ new Map(),
+		reExports: [],
+		exportAlls: []
+	};
+	for (const node of nodes) collectTypeOnlyLocals(node, info.typeOnlyLocals);
+	for (const node of nodes) await collectExportInfo(context, node, id, info);
+	return info;
+}
+function collectTypeOnlyLocals(node, typeOnlyLocals) {
+	if (node.type !== "ImportDeclaration") return;
+	for (const specifier of node.specifiers) if (node.importKind === "type" || "importKind" in specifier && specifier.importKind === "type") typeOnlyLocals.add(specifier.local.name);
+}
+function collectDeclarationNames(node) {
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((decl) => collectPatternNames(decl.id));
+	if ("id" in node && node.id) {
+		if (node.id.type !== "Identifier" && node.id.type !== "TSQualifiedName") return [];
+		const id = getIdFromTSEntityName(node.id);
+		return id.type === "Identifier" ? [id.name] : [];
+	}
+	return [];
+}
+function collectPatternNames(node) {
+	if (!node) return [];
+	if (node.type === "Identifier") return [node.name];
+	if (node.type === "RestElement") return collectPatternNames(node.argument);
+	if (node.type === "AssignmentPattern") return collectPatternNames(node.left);
+	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => collectPatternNames(element));
+	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => {
+		if (property.type === "RestElement") return collectPatternNames(property.argument);
+		return collectPatternNames(property.value);
+	});
+	return [];
+}
+function isTypeOnlyExport(node, specifier) {
+	return node.exportKind === "type" || "exportKind" in specifier && specifier.exportKind === "type";
+}
+async function collectExportInfo(context, node, id, info) {
+	if (node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			for (const name of collectDeclarationNames(node.declaration)) info.exports.set(name, false);
+			return;
+		}
+		const source = await resolveExportSource(context, node.source, id);
+		for (const specifier of node.specifiers) {
+			const typeOnly = isTypeOnlyExport(node, specifier);
+			if (specifier.type === "ExportSpecifier") {
+				const exported = resolveString(specifier.exported);
+				const local = resolveString(specifier.local);
+				if (source) info.reExports.push({
+					source,
+					local,
+					exported,
+					typeOnly
+				});
+				else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
+			} else {
+				const exported = resolveString(specifier.exported);
+				info.exports.set(exported, typeOnly);
+			}
 		}
-		return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
-			name,
-			typeParams
-		}));
+		return;
+	}
+	if (node.type === "ExportDefaultDeclaration") {
+		info.exports.set("default", false);
+		return;
 	}
-	function collectDependencies(node, namespaceStmts, children, identifierMap) {
-		const deps = /* @__PURE__ */ new Set();
-		const seen = /* @__PURE__ */ new Set();
-		const inferredStack = [];
-		let currentInferred = /* @__PURE__ */ new Set();
-		function isInferred(node) {
-			return node.type === "Identifier" && currentInferred.has(node.name);
+	if (node.type === "ExportAllDeclaration") info.exportAlls.push({
+		source: await resolveExportSource(context, node.source, id),
+		rawSource: node.source.value,
+		typeOnly: node.exportKind === "type"
+	});
+}
+async function resolveExportSource(context, source, importer) {
+	if (!source) return;
+	const resolved = await context.resolve(source.value, importer);
+	if (!resolved || resolved.external) return;
+	return resolved.id;
+}
+function collectChunkExportInfo(chunk, moduleExportsMap) {
+	const exportsByModule = resolveAllModuleExports(moduleExportsMap);
+	const roots = chunk.facadeModuleId && moduleExportsMap.has(chunk.facadeModuleId) ? [chunk.facadeModuleId] : chunk.moduleIds;
+	const mergedExports = /* @__PURE__ */ new Map();
+	const typeOnlyExportAllSources = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		const exports = exportsByModule.get(root);
+		if (exports) for (const [name, typeOnly] of exports) setExportTypeOnly(mergedExports, name, typeOnly);
+		const moduleExports = moduleExportsMap.get(root);
+		if (!moduleExports) continue;
+		for (const exportAll of moduleExports.exportAlls) {
+			if (!exportAll.typeOnly || exportAll.source) continue;
+			typeOnlyExportAllSources.add(exportAll.rawSource);
 		}
-		walkAST(node, {
-			enter(node) {
-				if (node.type === "TSConditionalType") {
-					const inferred = collectInferredNames(node.extendsType);
-					inferredStack.push(inferred);
-				}
-			},
-			leave(node, parent) {
-				if (node.type === "TSConditionalType") inferredStack.pop();
-				else if (parent?.type === "TSConditionalType") {
-					const trueBranch = parent.trueType === node;
-					currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
-				} else currentInferred = /* @__PURE__ */ new Set();
-				if (node.type === "ExportNamedDeclaration") {
-					for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
-				} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
-				else if (node.type === "ClassDeclaration") {
-					if (node.superClass) addDependency(node.superClass);
-					if (node.implements) for (const implement of node.implements) {
-						if (implement.type === "ClassImplements") throw new Error("Unexpected Flow syntax");
-						addDependency(implement.expression);
-					}
-				} else if (isTypeOf(node, [
-					"ObjectMethod",
-					"ObjectProperty",
-					"ClassProperty",
-					"TSPropertySignature",
-					"TSDeclareMethod"
-				])) {
-					if (node.computed && isReferenceId(node.key)) addDependency(node.key);
-					if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
-				} else switch (node.type) {
-					case "TSTypeReference":
-						addDependency(TSEntityNameToRuntime(node.typeName));
-						break;
-					case "TSTypeQuery":
-						if (seen.has(node.exprName)) return;
-						if (node.exprName.type === "TSImportType") break;
-						addDependency(TSEntityNameToRuntime(node.exprName));
-						break;
-					case "TSImportType": {
-						seen.add(node);
-						const { source, qualifier } = node;
-						addDependency(importNamespace(node, qualifier, source, namespaceStmts, identifierMap));
-						break;
-					}
+	}
+	const typeOnlyNames = /* @__PURE__ */ new Set();
+	for (const [name, typeOnly] of mergedExports) if (typeOnly) typeOnlyNames.add(name);
+	return {
+		typeOnlyNames,
+		typeOnlyExportAllSources
+	};
+}
+function resolveAllModuleExports(moduleExportsMap) {
+	const exportsByModule = /* @__PURE__ */ new Map();
+	for (const [id, info] of moduleExportsMap) exportsByModule.set(id, new Map(info.exports));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [id, info] of moduleExportsMap) {
+			const exports = exportsByModule.get(id);
+			for (const reExport of info.reExports) {
+				const sourceTypeOnly = (reExport.source ? exportsByModule.get(reExport.source) : void 0)?.get(reExport.local) ?? false;
+				if (setExportTypeOnly(exports, reExport.exported, reExport.typeOnly || sourceTypeOnly)) changed = true;
+			}
+			for (const exportAll of info.exportAlls) {
+				if (!exportAll.source) continue;
+				const sourceExports = exportsByModule.get(exportAll.source);
+				if (!sourceExports) continue;
+				for (const [name, typeOnly] of sourceExports) {
+					if (name === "default") continue;
+					if (setExportTypeOnly(exports, name, exportAll.typeOnly || typeOnly)) changed = true;
 				}
-				if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
 			}
-		});
-		return Array.from(deps);
-		function addDependency(node) {
-			if (isThisExpression(node) || isInferred(node)) return;
-			deps.add(node);
 		}
 	}
-	function importNamespace(node, imported, source, namespaceStmts, identifierMap) {
-		const sourceText = source.value.replaceAll(/\W/g, "_");
-		let local = {
+	return exportsByModule;
+}
+function setExportTypeOnly(exports, name, typeOnly) {
+	const current = exports.get(name);
+	if (current === false || current === typeOnly) return false;
+	if (current === void 0 || !typeOnly) {
+		exports.set(name, typeOnly);
+		return true;
+	}
+	return false;
+}
+/**
+* Collects all TSTypeParameter nodes from the given node and groups them by
+* their name. One name can associate with one or more type parameters. These
+* names will be used as the parameter name in the generated JavaScript
+* dependency function.
+*/
+function collectParams(node) {
+	const typeParams = [];
+	walkAST(node, { leave(node) {
+		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => typeof name === "string" ? {
 			type: "Identifier",
-			name: `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`
-		};
-		if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
-		else namespaceStmts.set(source.value, {
-			stmt: {
-				type: "ImportDeclaration",
-				specifiers: [{
-					type: "ImportNamespaceSpecifier",
-					local
-				}],
-				source,
-				attributes: null
-			},
-			local
-		});
-		if (imported) {
-			const importedLeft = getIdFromTSEntityName(imported);
-			if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
-			overwriteNode(importedLeft, {
-				type: "TSQualifiedName",
-				left: local,
-				right: { ...importedLeft }
-			});
-			local = imported;
-		}
-		let replacement = node;
-		if (node.typeArguments) {
-			overwriteNode(node, {
-				type: "TSTypeReference",
-				typeName: local,
-				typeArguments: node.typeArguments
-			});
-			replacement = local;
-		} else overwriteNode(node, local);
-		return {
-			...TSEntityNameToRuntime(local),
-			replace(newNode) {
-				overwriteNode(replacement, newNode);
+			name
+		} : name));
+	} });
+	const paramMap = /* @__PURE__ */ new Map();
+	for (const typeParam of typeParams) {
+		const name = typeParam.name;
+		const group = paramMap.get(name);
+		if (group) group.push(typeParam);
+		else paramMap.set(name, [typeParam]);
+	}
+	return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
+		name,
+		typeParams
+	}));
+}
+async function collectDependencies(context, node, importer, namespaceStmts, children, identifierMap) {
+	const deps = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const preserveImportTypeCache = /* @__PURE__ */ new Map();
+	const inferredStack = [];
+	let currentInferred = /* @__PURE__ */ new Set();
+	function isInferred(node) {
+		return node.type === "Identifier" && currentInferred.has(node.name);
+	}
+	await walkASTAsync(node, {
+		enter(node) {
+			if (node.type === "TSConditionalType") {
+				const inferred = collectInferredNames(node.extendsType);
+				inferredStack.push(inferred);
 			}
-		};
+			return Promise.resolve();
+		},
+		async leave(node, parent) {
+			if (node.type === "TSConditionalType") inferredStack.pop();
+			else if (parent?.type === "TSConditionalType") {
+				const trueBranch = parent.trueType === node;
+				currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
+			} else currentInferred = /* @__PURE__ */ new Set();
+			if (node.type === "ExportNamedDeclaration") {
+				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
+			} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
+			else if (node.type === "ClassDeclaration") {
+				if (node.superClass) addDependency(node.superClass);
+				if (node.implements) for (const implement of node.implements) {
+					if (implement.type === "ClassImplements") throw new Error("Unexpected Flow syntax");
+					addDependency(implement.expression);
+				}
+			} else if (isTypeOf(node, [
+				"ObjectMethod",
+				"ObjectProperty",
+				"ClassProperty",
+				"TSPropertySignature",
+				"TSDeclareMethod"
+			])) {
+				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
+				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
+			} else switch (node.type) {
+				case "TSTypeReference":
+					addDependency(TSEntityNameToRuntime(node.typeName));
+					break;
+				case "TSTypeQuery":
+					if (seen.has(node.exprName)) return;
+					if (node.exprName.type === "TSImportType") break;
+					addDependency(TSEntityNameToRuntime(node.exprName));
+					break;
+				case "TSImportType": {
+					seen.add(node);
+					const { source, qualifier } = node;
+					const dep = await importNamespace(context, importer, node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
+					if (dep) addDependency(dep);
+					break;
+				}
+			}
+			if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
+		}
+	});
+	return Array.from(deps);
+	function addDependency(node) {
+		if (isThisExpression(node) || isInferred(node)) return;
+		deps.add(node);
+	}
+}
+async function importNamespace(context, importer, node, imported, source, namespaceStmts, identifierMap, preserveCache) {
+	let preserve = preserveCache.get(source.value);
+	if (preserve === void 0) {
+		const resolved = await context.resolve(source.value, importer);
+		preserve = !resolved || !!resolved.external;
+		preserveCache.set(source.value, preserve);
+	}
+	if (preserve) return;
+	const sourceText = source.value.replaceAll(/\W/g, "_");
+	let local = {
+		type: "Identifier",
+		name: `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`
+	};
+	if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
+	else namespaceStmts.set(source.value, {
+		stmt: {
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportNamespaceSpecifier",
+				local
+			}],
+			source,
+			attributes: null
+		},
+		local
+	});
+	if (imported) {
+		const importedLeft = getIdFromTSEntityName(imported);
+		if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
+		overwriteNode(importedLeft, {
+			type: "TSQualifiedName",
+			left: local,
+			right: { ...importedLeft }
+		});
+		local = imported;
 	}
+	let replacement = node;
+	if (node.typeArguments) {
+		overwriteNode(node, {
+			type: "TSTypeReference",
+			typeName: local,
+			typeArguments: node.typeArguments
+		});
+		replacement = local;
+	} else overwriteNode(node, local);
+	return {
+		...TSEntityNameToRuntime(local),
+		replace(newNode) {
+			overwriteNode(replacement, newNode);
+		}
+	};
 }
 function isChildSymbol(node, parent) {
 	if (node.type === "Identifier") return true;
@@ -518,6 +661,9 @@ const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
 function collectReferenceDirectives(comment, negative = false) {
 	return comment.filter((c) => REFERENCE_RE.test(c.value) !== negative);
 }
+function isCjsDtsInputSyntax(node) {
+	return node.type === "TSExportAssignment" || node.type === "TSImportEqualsDeclaration" && node.moduleReference.type === "TSExternalModuleReference";
+}
 /**
 * Check if the given node is a {@link RuntimeBindingVariableDeclration}
 */
@@ -572,7 +718,7 @@ function isHelperImport(node) {
 /**
 * patch `.d.ts` suffix in import source to `.js`
 */
-function patchImportExport(node, typeOnlyIds, cjsDefault) {
+function patchImportExport(node, exportInfo, cjsDefault) {
 	if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && !node.specifiers.length && !node.attributes?.length) return false;
 	if (node.type === "ImportDeclaration" && node.specifiers.length) {
 		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
@@ -582,10 +728,14 @@ function patchImportExport(node, typeOnlyIds, cjsDefault) {
 		"ExportAllDeclaration",
 		"ExportNamedDeclaration"
 	])) {
-		if (node.type === "ExportNamedDeclaration" && typeOnlyIds.length) for (const spec of node.specifiers) {
-			const name = resolveString(spec.exported);
-			if (typeOnlyIds.includes(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
-			else node.exportKind = "type";
+		if (node.type === "ExportAllDeclaration" && node.source && exportInfo.typeOnlyExportAllSources.has(node.source.value)) node.exportKind = "type";
+		if (node.type === "ExportNamedDeclaration" && exportInfo.typeOnlyNames.size) {
+			for (const spec of node.specifiers) {
+				const name = resolveString(spec.exported);
+				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
+				else node.exportKind = "type";
+			}
+			normalizeTypeOnlyExport(node);
 		}
 		if (node.source?.value && RE_DTS.test(node.source.value)) {
 			node.source.value = filename_dts_to(node.source.value, "js");
@@ -597,13 +747,19 @@ function patchImportExport(node, typeOnlyIds, cjsDefault) {
 		};
 	}
 }
+function normalizeTypeOnlyExport(node) {
+	if (node.declaration || !node.specifiers.length) return;
+	for (const specifier of node.specifiers) if (specifier.type !== "ExportSpecifier" || specifier.exportKind !== "type") return;
+	node.exportKind = "type";
+	for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+}
 /**
 * Handle `__exportAll` call
 */
 function patchTsNamespace(nodes) {
 	const removed = /* @__PURE__ */ new Set();
 	for (const [i, node] of nodes.entries()) {
-		const result = handleExport(node);
+		const result = getExportAllNamespace(node);
 		if (!result) continue;
 		const [binding, exports] = result;
 		if (!exports.properties.length) continue;
@@ -630,10 +786,10 @@ function patchTsNamespace(nodes) {
 		};
 	}
 	return nodes.filter((node) => !removed.has(node));
-	function handleExport(node) {
-		if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
-		return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
-	}
+}
+function getExportAllNamespace(node) {
+	if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
+	return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
 }
 /**
 * Handle `__reExport` call
@@ -668,13 +824,10 @@ function patchReExport(nodes) {
 	else if (node.type === "ExportNamedDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && node.specifiers[0].local.type === "Identifier" && exportsNames.has(node.specifiers[0].local.name)) node.specifiers[0].local.name = exportsNames.get(node.specifiers[0].local.name);
 	return nodes;
 }
-function rewriteImportExport(node, set, typeOnlyIds) {
+function rewriteImportExport(node, set) {
 	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
-		for (const specifier of node.specifiers) {
-			if ("exportKind" in specifier && specifier.exportKind === "type" || "exportKind" in node && node.exportKind === "type") typeOnlyIds.push(resolveString(specifier.exported));
-			if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
-			else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
-		}
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
+		else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
 		if (node.type === "ImportDeclaration") node.importKind = "value";
 		else if (node.type === "ExportNamedDeclaration") node.exportKind = "value";
 		return true;
@@ -732,6 +885,10 @@ function inheritNodeComments(oldNode, newNode) {
 	newNode.leadingComments = collectReferenceDirectives(newNode.leadingComments, true);
 	return newNode;
 }
+function getIdentifierIndex(identifierMap, name) {
+	if (name in identifierMap) return ++identifierMap[name];
+	return identifierMap[name] = 0;
+}
 //#endregion
 //#region src/tsgo.ts
 const debug$3 = createDebug("rolldown-plugin-dts:tsgo");

package/dist/tsc.d.mts

@@ -1,2 +1,2 @@
 import { i as TscResult, n as TscModule, r as TscOptions, t as tscEmit } from "./index-CJhxyVA1.mjs";
-export { TscModule, TscOptions, TscResult, tscEmit };
+export { type TscModule, type TscOptions, type TscResult, tscEmit };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rolldown-plugin-dts",
   "type": "module",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "A Rolldown plugin to generate and bundle dts files.",
   "author": "Kevin Deng <sxzz@sxzz.moe>",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "@ts-macro/tsc": "^0.3.6",
     "@typescript/native-preview": ">=7.0.0-dev.20260325.1",
     "rolldown": "^1.0.0",
-    "typescript": "^6.0.0",
+    "typescript": "^5.0.0 || ^6.0.0",
     "vue-tsc": "~3.2.0"
   },
   "peerDependenciesMeta": {
@@ -62,8 +62,8 @@
     }
   },
   "dependencies": {
-    "@babel/generator": "8.0.0-rc.4",
-    "@babel/helper-validator-identifier": "8.0.0-rc.4",
+    "@babel/generator": "8.0.0-rc.5",
+    "@babel/helper-validator-identifier": "8.0.0-rc.5",
     "@babel/parser": "8.0.0-rc.4",
     "ast-kit": "^3.0.0-beta.1",
     "birpc": "^4.0.0",
@@ -74,27 +74,27 @@
   "devDependencies": {
     "@babel/types": "^8.0.0-rc.4",
     "@jridgewell/source-map": "^0.3.11",
-    "@sxzz/eslint-config": "^8.0.0",
+    "@sxzz/eslint-config": "^8.1.0",
     "@sxzz/prettier-config": "^2.3.1",
     "@sxzz/test-utils": "^0.5.18",
-    "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260507.1",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260515.1",
     "@volar/typescript": "^2.4.28",
-    "@vue/language-core": "^3.2.8",
+    "@vue/language-core": "^3.2.9",
     "arktype": "^2.2.0",
     "bumpp": "^11.1.0",
     "diff": "^9.0.0",
-    "eslint": "^10.3.0",
+    "eslint": "^10.4.0",
     "prettier": "^3.8.3",
-    "rolldown": "^1.0.0",
+    "rolldown": "^1.0.1",
     "rolldown-plugin-require-cjs": "^0.4.0",
     "rollup-plugin-dts": "^6.4.1",
-    "tsdown": "^0.22.0-beta.3",
-    "tsnapi": "^0.3.2",
+    "tsdown": "^0.22.0",
+    "tsnapi": "^0.3.3",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5",
+    "vitest": "^4.1.6",
     "vue": "^3.5.34",
-    "vue-tsc": "^3.2.8",
+    "vue-tsc": "^3.2.9",
     "zod": "^4.4.3"
   },
   "prettier": "@sxzz/prettier-config",