rolldown-plugin-dts 0.5.2 → 0.7.0

package/README.md

@@ -29,7 +29,7 @@ You can find a real demo in [here](./rolldown.config.ts).
 
 ## Options
 
-````ts
+```ts
 interface Options {
   /**
    * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
@@ -47,44 +47,32 @@ interface Options {
 
   /**
    * The `compilerOptions` for the TypeScript compiler.
+   * The default value will be inferred from the `tsconfig.json` file.
    *
    * @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
    */
-  compilerOptions?: CompilerOptions
+  compilerOptions?: TsConfigJson.CompilerOptions
   /**
    * When `true`, the plugin will generate `.d.ts` files using `oxc-transform`,
    * which is blazingly faster than `typescript` compiler.
    *
-   * This option is enabled when `isolatedDeclaration` in `tsconfig.json` is set to `true`.
+   * This option is enabled when `isolatedDeclaration` in `compilerOptions` is set to `true`.
    */
   isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, 'sourcemap'>
-  /**
-   * dts file name alias `{ [filename]: path }`
-   *
-   * @example
-   * ```ts
-   * inputAlias: {
-   *   'foo.d.ts': 'foo/index.d.ts',
-   * }
-   */
-  inputAlias?: Record<string, string>
 
   /** Resolve external types used in dts files from `node_modules` */
   resolve?: boolean | (string | RegExp)[]
 }
-````
+```
 
-## ⚠️ 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,13 +1,13 @@
+import { TsConfigJson } from "get-tsconfig";
 import { IsolatedDeclarationsOptions } from "oxc-transform";
 import { Plugin } from "rolldown";
-import { CompilerOptions } from "typescript";
 
 //#region src/fake-js.d.ts
 declare function createFakeJsPlugin({ dtsInput }: Pick<Options, "dtsInput">): Plugin;
 
 //#endregion
 //#region src/generate.d.ts
-declare function createGeneratePlugin({ compilerOptions, isolatedDeclaration, inputAlias, resolve, emitDtsOnly }: Pick<Options, "isolatedDeclaration" | "inputAlias" | "resolve" | "emitDtsOnly" | "compilerOptions">): Plugin;
+declare function createGeneratePlugin({ compilerOptions, isolatedDeclaration, resolve, emitDtsOnly }: Pick<Options, "isolatedDeclaration" | "resolve" | "emitDtsOnly" | "compilerOptions">): Plugin;
 
 //#endregion
 //#region src/index.d.ts
@@ -26,27 +26,18 @@ interface Options {
 	emitDtsOnly?: boolean;
 	/**
 	* The `compilerOptions` for the TypeScript compiler.
+	* The default value will be inferred from the `tsconfig.json` file.
 	*
 	* @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
 	*/
-	compilerOptions?: CompilerOptions;
+	compilerOptions?: TsConfigJson.CompilerOptions;
 	/**
 	* When `true`, the plugin will generate `.d.ts` files using `oxc-transform`,
 	* which is blazingly faster than `typescript` compiler.
 	*
-	* This option is enabled when `isolatedDeclaration` in `tsconfig.json` is set to `true`.
+	* This option is enabled when `isolatedDeclaration` in `compilerOptions` is set to `true`.
 	*/
 	isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
-	/**
-	* dts file name alias `{ [filename]: path }`
-	*
-	* @example
-	* ```ts
-	* inputAlias: {
-	*   'foo.d.ts': 'foo/index.d.ts',
-	* }
-	*/
-	inputAlias?: Record<string, string>;
 	/** Resolve external types used in dts files from `node_modules` */
 	resolve?: boolean | (string | RegExp)[];
 }

package/dist/index.js

@@ -1,10 +1,12 @@
 import { MagicStringAST } from "magic-string-ast";
 import { parseSync } from "oxc-parser";
-import path, { basename, extname } from "node:path";
+import path from "node:path";
+import process from "node:process";
 import { createResolver } from "dts-resolver";
 import { getTsconfig } from "get-tsconfig";
 import { isolatedDeclaration } from "oxc-transform";
 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 {
@@ -256,7 +258,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;
@@ -315,17 +316,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;
@@ -342,7 +345,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;
 		}
 	};
@@ -374,15 +377,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
 			});
 		}
 	} });
@@ -398,16 +400,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, ""));
@@ -422,7 +448,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 }`);
@@ -431,15 +457,18 @@ 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
+const debug = Debug("rolldown-plugin-dts:tsc");
 let ts;
 let formatHost;
 function initTs() {
+	debug("loading typescript");
 	const require = createRequire(import.meta.url);
 	ts = require("typescript");
 	formatHost = {
@@ -447,6 +476,7 @@ function initTs() {
 		getNewLine: () => ts.sys.newLine,
 		getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 	};
+	debug(`loaded typescript: ${ts.version}`);
 }
 const defaultCompilerOptions = {
 	declaration: true,
@@ -472,16 +502,18 @@ 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;
 }
 function createTsProgram(compilerOptions, id, code) {
 	const files = new Map([[id, code]]);
+	const overrideCompilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, ".").options;
 	const options = {
 		...defaultCompilerOptions,
-		...loadTsconfig(id),
-		...compilerOptions
+		...overrideCompilerOptions
 	};
 	const host = ts.createCompilerHost(options, true);
 	const { readFile: _readFile, fileExists: _fileExists } = host;
@@ -493,14 +525,7 @@ function createTsProgram(compilerOptions, id, code) {
 		if (files.has(fileName)) return files.get(fileName);
 		return _readFile(fileName);
 	};
-	const program = ts.createProgram([id], {
-		...compilerOptions,
-		moduleResolution: ts.ModuleResolutionKind.Node10,
-		declaration: true,
-		emitDeclarationOnly: true,
-		outDir: void 0,
-		declarationDir: void 0
-	}, host);
+	const program = ts.createProgram([id], options, host);
 	const sourceFile = program.getSourceFile(id);
 	if (!sourceFile) throw new Error(`Source file not found: ${id}`);
 	return {
@@ -511,39 +536,60 @@ function createTsProgram(compilerOptions, id, code) {
 		file: sourceFile
 	};
 }
-const tsconfigCache = new Map();
-function loadTsconfig(id) {
-	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.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;
+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 };
 }
 
 //#endregion
 //#region src/generate.ts
 const meta = { dtsFile: true };
-function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDeclaration$1, inputAlias, resolve = false, emitDtsOnly = false }) {
+function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDeclaration$1, resolve = false, emitDtsOnly = false }) {
 	const dtsMap = new Map();
-	const inputAliasMap = new Map(inputAlias && Object.entries(inputAlias));
+	/**
+	* A map of input id to output file name
+	*
+	* @example
+	*
+	* inputAlias = new Map([
+	*   ['/absolute/path/to/src/source_file.ts', 'dist/foo/index'],
+	* ])
+	*/
+	const inputAliasMap = new Map();
 	const resolver = createResolver();
 	let programs = [];
-	let inputOption;
 	return {
 		name: "rolldown-plugin-dts:generate",
 		buildStart(options) {
-			if (isolatedDeclaration$1 == null) {
+			if (!compilerOptions) {
 				const { config } = getTsconfig(options.cwd) || {};
-				if (config?.compilerOptions?.isolatedDeclarations) isolatedDeclaration$1 = { stripInternal: !!config?.compilerOptions.stripInternal };
+				compilerOptions = config?.compilerOptions;
 			}
+			if (isolatedDeclaration$1 == null) isolatedDeclaration$1 = !!compilerOptions?.isolatedDeclarations;
+			if (isolatedDeclaration$1 === true) isolatedDeclaration$1 = {};
+			if (isolatedDeclaration$1 && isolatedDeclaration$1.stripInternal == null) isolatedDeclaration$1.stripInternal = !!compilerOptions?.stripInternal;
 			if (!isolatedDeclaration$1) initTs();
-		},
-		options({ input }) {
-			if (isPlainObject(input)) inputOption = { ...input };
+			if (!Array.isArray(options.input)) {
+				const cwd = options.cwd || process.cwd();
+				for (const [fileName, inputFilePath] of Object.entries(options.input)) {
+					const id = path.resolve(cwd, inputFilePath);
+					inputAliasMap.set(id, fileName);
+				}
+			}
 		},
 		outputOptions(options) {
 			return {
@@ -567,22 +613,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);
@@ -591,19 +634,17 @@ function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDe
 					src: id
 				});
 				if (isEntry) {
-					let name = basename(dtsId, extname(dtsId));
-					if (inputAliasMap.has(name)) name = inputAliasMap.get(name);
-					else if (inputAliasMap.has(dtsId)) name = inputAliasMap.get(dtsId);
+					const name = inputAliasMap.get(id);
 					this.emitFile({
 						type: "chunk",
 						id: dtsId,
-						name
+						name: name ? `${name}.d` : void 0
 					});
 					if (emitDtsOnly) return "//";
 				}
 			}
 		},
-		async resolveId(id, importer, extraOptions) {
+		async resolveId(id, importer) {
 			if (dtsMap.has(id)) return {
 				id,
 				meta
@@ -637,16 +678,6 @@ function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDe
 					id: dtsId,
 					meta
 				};
-			} else if (extraOptions.isEntry && inputOption) {
-				const resolution = await this.resolve(id, importer, extraOptions);
-				if (!resolution) return;
-				const dtsId = filename_ts_to_dts(resolution.id);
-				if (inputAliasMap.has(dtsId)) return resolution;
-				for (const [name, entry] of Object.entries(inputOption)) if (entry === id) {
-					inputAliasMap.set(dtsId, `${name}.d.ts`);
-					break;
-				}
-				return resolution;
 			}
 		},
 		load: {
@@ -669,11 +700,6 @@ function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDe
 		}
 	};
 }
-function isPlainObject(data) {
-	if (typeof data !== "object" || data === null) return false;
-	const proto = Object.getPrototypeOf(data);
-	return proto === null || proto === Object.prototype;
-}
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.5.2",
+  "version": "0.7.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",