rolldown-plugin-dts 0.5.1 → 0.6.0

package/README.md

@@ -74,17 +74,14 @@ interface Options {
 }
 ````
 
-## ⚠️ Caveats
+## Differences from `rollup-plugin-dts`
 
-- The plugin leverages Oxc's `isolatedDeclarations` to generate `.d.ts` files when `isolatedDeclaration` is enabled,
-  offering significantly faster performance compared to the `typescript` compiler.
+### Isolated Declarations
 
-- Namespaces are not supported yet.
-  - `export * as ns from './ns'`
-  - `import * as ns from './ns'` and then `export { ns }`
-  - `type ns = import('./ns')`
+The plugin leverages Oxc's `isolatedDeclarations` to generate `.d.ts` files when `isolatedDeclaration` is enabled,
+offering significantly faster performance compared to the `typescript` compiler.
 
-## Differences from `rollup-plugin-dts`
+### Single Build for ESM
 
 `rolldown-plugin-dts` generates separate chunks for `.d.ts` files, enabling both source code (`.js`)
 and type definition files (`.d.ts`) to be produced in a single build process.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { IsolatedDeclarationsOptions } from "oxc-transform";
-import { CompilerOptions } from "typescript";
 import { Plugin } from "rolldown";
+import { CompilerOptions } from "typescript";
 
 //#region src/fake-js.d.ts
 declare function createFakeJsPlugin({ dtsInput }: Pick<Options, "dtsInput">): Plugin;

package/dist/index.js

@@ -4,8 +4,8 @@ import path, { basename, extname } from "node:path";
 import { createResolver } from "dts-resolver";
 import { getTsconfig } from "get-tsconfig";
 import { isolatedDeclaration } from "oxc-transform";
-import * as ts from "typescript";
 import { createRequire } from "node:module";
+import Debug from "debug";
 
 //#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
 var WalkerBase = class {
@@ -257,7 +257,6 @@ function createFakeJsPlugin({ dtsInput }) {
 				preserveMap.set(id, preserved);
 				const s = new MagicStringAST(code);
 				for (let node of program.body) {
-					if (node.type === "ExportAllDeclaration" && node.exported && isRelative(node.source.value)) throw new Error("`export * as foo from './...'` is not supported");
 					if (rewriteImportExport(s, node)) continue;
 					const sideEffect = node.type === "TSModuleDeclaration" && node.kind !== "namespace";
 					const stmt = node;
@@ -316,17 +315,19 @@ function createFakeJsPlugin({ dtsInput }) {
 				}
 			}
 			if (comments.size) s.prepend(`${[...comments].join("\n")}\n`);
+			const removedNodes = patchTsNamespace(s, program.body);
 			for (const node of program.body) {
+				if (removedNodes.has(node)) continue;
 				if (patchImportSource(s, node)) continue;
 				if (node.type !== "VariableDeclaration" || node.declarations.length !== 1) continue;
 				const [decl] = node.declarations;
 				if (decl.init?.type !== "ArrayExpression" || !decl.init.elements[0]) {
-					patchVariableDeclarator(s, node, decl);
+					s.removeNode(node);
 					continue;
 				}
 				const [symbolIdNode, ...depsNodes] = decl.init.elements;
 				if (symbolIdNode?.type !== "Literal" || typeof symbolIdNode.value !== "number") {
-					patchVariableDeclarator(s, node, decl);
+					s.removeNode(node);
 					continue;
 				}
 				const symbolId = symbolIdNode.value;
@@ -343,7 +344,7 @@ function createFakeJsPlugin({ dtsInput }) {
 				s.overwriteNode(node, ss.toString());
 			}
 			const str = s.toString();
-			if (str.trim().length === 0) return "export {}";
+			if (str.trim().length === 0) return "export { };";
 			return str;
 		}
 	};
@@ -375,15 +376,14 @@ function collectDependencies(s, node, getIdentifierIndex) {
 		else if (node$1.type === "TSTypeQuery") addDependency(node$1.exprName);
 		else if (node$1.type === "TSImportType") {
 			if (node$1.argument.type !== "TSLiteralType" || node$1.argument.literal.type !== "Literal" || typeof node$1.argument.literal.value !== "string") return;
-			if (!node$1.qualifier) throw new Error("Import namespace is not supported");
 			const source = node$1.argument.literal.value;
-			const imported = s.sliceNode(node$1.qualifier);
+			const imported = node$1.qualifier && s.sliceNode(node$1.qualifier);
 			const local = importNamespace(s, source, imported, getIdentifierIndex);
 			addDependency({
 				type: "Identifier",
 				name: local,
 				start: node$1.start + (node$1.isTypeOf ? 7 : 0),
-				end: node$1.qualifier.end
+				end: node$1.qualifier ? node$1.qualifier.end : node$1.end
 			});
 		}
 	} });
@@ -399,16 +399,40 @@ function isReferenceId(node) {
 function stringifyDependencies(s, deps) {
 	return deps.map((node) => `() => ${node.type === "Identifier" ? node.name : s.sliceNode(node)}`).join(", ");
 }
-function patchVariableDeclarator(s, node, decl) {
-	if (decl.init && !decl.id.typeAnnotation) s.overwriteNode(node, `type ${s.sliceNode(decl.id)} = ${s.sliceNode(decl.init)}`);
-	else if (!node.declare) s.prependLeft(node.start, "declare ");
-}
 function patchImportSource(s, node) {
 	if ((node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value && RE_DTS.test(node.source.value)) {
 		s.overwriteNode(node.source, JSON.stringify(filename_dts_to(node.source.value, "js")));
 		return true;
 	}
 }
+function patchTsNamespace(s, nodes) {
+	const emptyObjectAssignments = new Map();
+	const removed = new Set();
+	for (const node of nodes) {
+		if (node.type === "VariableDeclaration" && node.declarations.length === 1 && node.declarations[0].init?.type === "ObjectExpression" && node.declarations[0].init.properties.length === 0) emptyObjectAssignments.set(s.sliceNode(node.declarations[0].id), node);
+		if (node.type !== "ExpressionStatement" || node.expression.type !== "CallExpression" || node.expression.callee.type !== "Identifier" || !node.expression.callee.name.startsWith("__export")) continue;
+		const [binding, exports] = node.expression.arguments;
+		const bindingText = s.sliceNode(binding);
+		if (emptyObjectAssignments.has(bindingText)) {
+			const emptyNode = emptyObjectAssignments.get(bindingText);
+			s.removeNode(emptyNode);
+			emptyObjectAssignments.delete(bindingText);
+			removed.add(emptyNode);
+		}
+		let code = `declare namespace ${bindingText} {
+  export { `;
+		for (const properties of exports.properties) {
+			if (properties.type !== "Property") continue;
+			const exported = s.sliceNode(properties.key);
+			const local = s.sliceNode(properties.value.body);
+			const suffix = exported !== local ? ` as ${exported}` : "";
+			code += `${local}${suffix}, `;
+		}
+		code += `}\n}`;
+		s.overwriteNode(node, code);
+	}
+	return removed;
+}
 function rewriteImportExport(s, node) {
 	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
 		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.importKind === "type" || specifier.type === "ExportSpecifier" && specifier.exportKind === "type") s.overwriteNode(specifier, s.sliceNode(specifier).replace(RE_TYPE, ""));
@@ -423,7 +447,7 @@ function rewriteImportExport(s, node) {
 		if (node.moduleReference.type === "TSExternalModuleReference") s.overwriteNode(node, `import ${s.sliceNode(node.id)} from ${s.sliceNode(node.moduleReference.expression)}`);
 		return true;
 	} else if (node.type === "TSExportAssignment") {
-		s.overwriteNode(node, `export default ${s.sliceNode(node.expression)}`);
+		s.overwriteNode(node, `export { ${s.sliceNode(node.expression)} as default }`);
 		return true;
 	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
 		s.overwriteNode(node, `export { ${s.sliceNode(node.declaration)} as default }`);
@@ -432,22 +456,26 @@ function rewriteImportExport(s, node) {
 }
 function importNamespace(s, source, imported, getIdentifierIndex) {
 	const local = `_${getIdentifierIndex()}`;
-	s.prepend(`import { ${imported} as ${local} } from ${JSON.stringify(source)};\n`);
+	const specifiers = imported ? `{ ${imported} as ${local} }` : `* as ${local}`;
+	s.prepend(`import ${specifiers} from ${JSON.stringify(source)};\n`);
 	return local;
 }
 
 //#endregion
 //#region src/utils/tsc.ts
-let ts$1;
+const debug = Debug("rolldown-plugin-dts:tsc");
+let ts;
 let formatHost;
 function initTs() {
+	debug("loading typescript");
 	const require = createRequire(import.meta.url);
-	ts$1 = require("typescript");
+	ts = require("typescript");
 	formatHost = {
-		getCurrentDirectory: () => ts$1.sys.getCurrentDirectory(),
-		getNewLine: () => ts$1.sys.newLine,
-		getCanonicalFileName: ts$1.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+		getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+		getNewLine: () => ts.sys.newLine,
+		getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 	};
+	debug(`loaded typescript: ${ts.version}`);
 }
 const defaultCompilerOptions = {
 	declaration: true,
@@ -473,7 +501,9 @@ function createOrGetTsModule(programs, compilerOptions, id, code, isEntry) {
 			file: sourceFile
 		};
 	}
+	debug(`create program for module: ${id}`);
 	const module = createTsProgram(compilerOptions, id, code);
+	debug(`created program for module: ${id}`);
 	programs.push(module.program);
 	return module;
 }
@@ -484,7 +514,7 @@ function createTsProgram(compilerOptions, id, code) {
 		...loadTsconfig(id),
 		...compilerOptions
 	};
-	const host = ts$1.createCompilerHost(options, true);
+	const host = ts.createCompilerHost(options, true);
 	const { readFile: _readFile, fileExists: _fileExists } = host;
 	host.fileExists = (fileName) => {
 		if (files.has(fileName)) return true;
@@ -494,9 +524,9 @@ function createTsProgram(compilerOptions, id, code) {
 		if (files.has(fileName)) return files.get(fileName);
 		return _readFile(fileName);
 	};
-	const program = ts$1.createProgram([id], {
+	const program = ts.createProgram([id], {
 		...compilerOptions,
-		moduleResolution: ts$1.ModuleResolutionKind.Node10,
+		moduleResolution: ts.ModuleResolutionKind.Node10,
 		declaration: true,
 		emitDeclarationOnly: true,
 		outDir: void 0,
@@ -512,15 +542,33 @@ function createTsProgram(compilerOptions, id, code) {
 		file: sourceFile
 	};
 }
+function tscEmit(module) {
+	const { program: { program }, file } = module;
+	let dtsCode;
+	const { emitSkipped, diagnostics } = program.emit(
+		file,
+		(_, code) => {
+			debug(`emit dts: ${file.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 };
+}
 const tsconfigCache = new Map();
 function loadTsconfig(id) {
-	const configPath = ts$1.findConfigFile(path.dirname(id), ts$1.sys.fileExists);
+	const configPath = ts.findConfigFile(path.dirname(id), ts.sys.fileExists);
 	if (!configPath) return {};
 	if (tsconfigCache.has(configPath)) return tsconfigCache.get(configPath);
-	const { config, error } = ts$1.readConfigFile(configPath, ts$1.sys.readFile);
-	if (error) throw ts$1.formatDiagnostic(error, formatHost);
-	const configContents = ts$1.parseJsonConfigFileContent(config, ts$1.sys, path.dirname(configPath));
-	if (configContents.errors.length) throw ts$1.formatDiagnostics(configContents.errors, formatHost);
+	const { config, error } = ts.readConfigFile(configPath, ts.sys.readFile);
+	if (error) throw ts.formatDiagnostic(error, formatHost);
+	const configContents = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(configPath));
+	if (configContents.errors.length) throw ts.formatDiagnostics(configContents.errors, formatHost);
 	tsconfigCache.set(configPath, configContents.options);
 	return configContents.options;
 }
@@ -568,22 +616,19 @@ function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDe
 				const isEntry = mod?.isEntry;
 				if (isolatedDeclaration$1) {
 					const result = isolatedDeclaration(id, code, isolatedDeclaration$1 === true ? {} : isolatedDeclaration$1);
-					if (result.errors.length) return this.error(result.errors[0]);
+					if (result.errors.length) {
+						const [error] = result.errors;
+						return this.error({
+							message: error.message,
+							frame: error.codeframe
+						});
+					}
 					dtsCode = result.code;
 				} else {
-					const { program: { program }, file } = createOrGetTsModule(programs, compilerOptions, id, code, isEntry);
-					const { emitSkipped, diagnostics } = program.emit(
-						file,
-						(_, code$1) => {
-							dtsCode = code$1;
-						},
-						void 0,
-						true,
-						void 0,
-						// @ts-expect-error private API: forceDtsEmit
-						true
-);
-					if (emitSkipped && diagnostics.length) return this.error(ts.formatDiagnostics(diagnostics, formatHost));
+					const module = createOrGetTsModule(programs, compilerOptions, id, code, isEntry);
+					const result = tscEmit(module);
+					if (result.error) return this.error(result.error);
+					dtsCode = result.code;
 				}
 				if (!dtsCode) return this.error(new Error(`Failed to generate dts for ${id}`));
 				const dtsId = filename_ts_to_dts(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "A Rolldown plugin to bundle dts files",
   "type": "module",
   "license": "MIT",
@@ -37,6 +37,7 @@
     }
   },
   "dependencies": {
+    "debug": "^4.4.0",
     "dts-resolver": "^0.1.0",
     "get-tsconfig": "^4.10.0",
     "magic-string-ast": "^0.9.1",
@@ -47,6 +48,7 @@
     "@sxzz/eslint-config": "^6.1.1",
     "@sxzz/prettier-config": "^2.2.1",
     "@sxzz/test-utils": "^0.5.4",
+    "@types/debug": "^4.1.12",
     "@types/diff": "^7.0.2",
     "@types/node": "^22.14.0",
     "bumpp": "^10.1.0",