rolldown-plugin-dts 0.3.0 → 0.5.0

package/README.md

@@ -38,8 +38,26 @@ interface Options {
    */
   dtsInput?: boolean
 
-  isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, 'sourcemap'>
+  /**
+   * When `true`, the plugin will only emit `.d.ts` files and remove all other 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.
+   */
+  emitDtsOnly?: boolean
 
+  /**
+   * The `compilerOptions` for the TypeScript compiler.
+   *
+   * @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
+   */
+  compilerOptions?: 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`.
+   */
+  isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, 'sourcemap'>
   /**
    * dts file name alias `{ [filename]: path }`
    *
@@ -56,16 +74,26 @@ interface Options {
 }
 ````
 
-## Caveats
+## ⚠️ Caveats
 
-- The plugin uses Oxc's `isolatedDeclarations` to generate `.d.ts` files,
-  which means you need to set `isolatedDeclarations: true` in your `tsconfig.json` and ensure there are no errors.
+- The plugin leverages Oxc's `isolatedDeclarations` to generate `.d.ts` files when `isolatedDeclaration` is enabled,
+  offering significantly faster performance compared to the `typescript` compiler.
 
 - Namespaces are not supported yet.
   - `export * as ns from './ns'`
   - `import * as ns from './ns'` and then `export { ns }`
   - `type ns = import('./ns')`
 
+## Differences from `rollup-plugin-dts`
+
+`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.
+
+However, this functionality is limited to ESM output format. Consequently,
+**two** distinct build processes are required for CommonJS source code (`.cjs`)
+and its corresponding type definition files (`.d.cts`).
+In such cases, the `emitDtsOnly` option can be particularly helpful.
+
 ## Credits
 
 The project is inspired by [rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts)

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { IsolatedDeclarationsOptions } from "oxc-transform";
+import { CompilerOptions } from "typescript";
 import { Plugin } from "rolldown";
 
 //#region src/fake-js.d.ts
@@ -6,7 +7,7 @@ declare function createFakeJsPlugin({ dtsInput }: Pick<Options, "dtsInput">): Pl
 
 //#endregion
 //#region src/generate.d.ts
-declare function createGeneratePlugin({ isolatedDeclaration, inputAlias, resolve }: Pick<Options, "isolatedDeclaration" | "inputAlias" | "resolve">): Plugin;
+declare function createGeneratePlugin({ compilerOptions, isolatedDeclaration, inputAlias, resolve, emitDtsOnly }: Pick<Options, "isolatedDeclaration" | "inputAlias" | "resolve" | "emitDtsOnly" | "compilerOptions">): Plugin;
 
 //#endregion
 //#region src/index.d.ts
@@ -17,7 +18,25 @@ interface Options {
 	* If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
 	*/
 	dtsInput?: boolean;
-	isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, "sourcemap">;
+	/**
+	* When `true`, the plugin will only emit `.d.ts` files and remove all other 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.
+	*/
+	emitDtsOnly?: boolean;
+	/**
+	* The `compilerOptions` for the TypeScript compiler.
+	*
+	* @see https://www.typescriptlang.org/docs/handbook/compiler-options.html
+	*/
+	compilerOptions?: 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`.
+	*/
+	isolatedDeclaration?: boolean | Omit<IsolatedDeclarationsOptions, "sourcemap">;
 	/**
 	* dts file name alias `{ [filename]: path }`
 	*

package/dist/index.js

@@ -1,8 +1,11 @@
 import { MagicStringAST } from "magic-string-ast";
 import { parseAsync } from "oxc-parser";
-import path, { basename } from "node:path";
+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$1 from "typescript";
+import * as ts from "typescript";
 
 //#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
 var WalkerBase = class {
@@ -433,19 +436,119 @@ function importNamespace(s, source, imported, getIdentifierIndex) {
 	return local;
 }
 
+//#endregion
+//#region src/utils/tsc.ts
+const defaultCompilerOptions = {
+	declaration: true,
+	noEmit: false,
+	emitDeclarationOnly: true,
+	noEmitOnError: true,
+	checkJs: false,
+	declarationMap: false,
+	skipLibCheck: true,
+	preserveSymlinks: true,
+	target: ts$1.ScriptTarget.ESNext,
+	resolveJsonModule: true
+};
+const formatHost = {
+	getCurrentDirectory: () => ts$1.sys.getCurrentDirectory(),
+	getNewLine: () => ts$1.sys.newLine,
+	getCanonicalFileName: ts$1.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+};
+function createOrGetTsModule(programs, compilerOptions, id, code, isEntry) {
+	const tsProgram = programs.find(({ program }) => {
+		if (isEntry) return program.getRootFileNames().includes(id);
+		return program.getSourceFile(id);
+	});
+	if (tsProgram) {
+		const sourceFile = tsProgram.program.getSourceFile(id);
+		if (sourceFile) return {
+			program: tsProgram,
+			file: sourceFile
+		};
+	}
+	const module = createTsProgram(compilerOptions, id, code);
+	programs.push(module.program);
+	return module;
+}
+function createTsProgram(compilerOptions, id, code) {
+	const files = new Map([[id, code]]);
+	const options = {
+		...defaultCompilerOptions,
+		...loadTsconfig(id),
+		...compilerOptions
+	};
+	const host = ts$1.createCompilerHost(options, true);
+	const { readFile: _readFile, fileExists: _fileExists } = host;
+	host.fileExists = (fileName) => {
+		if (files.has(fileName)) return true;
+		return _fileExists(fileName);
+	};
+	host.readFile = (fileName) => {
+		if (files.has(fileName)) return files.get(fileName);
+		return _readFile(fileName);
+	};
+	const program = ts$1.createProgram([id], {
+		...compilerOptions,
+		moduleResolution: ts$1.ModuleResolutionKind.Node10,
+		declaration: true,
+		emitDeclarationOnly: true,
+		outDir: void 0,
+		declarationDir: void 0
+	}, host);
+	const sourceFile = program.getSourceFile(id);
+	if (!sourceFile) throw new Error(`Source file not found: ${id}`);
+	return {
+		program: {
+			program,
+			files
+		},
+		file: sourceFile
+	};
+}
+const tsconfigCache = new Map();
+function loadTsconfig(id) {
+	const configPath = ts$1.findConfigFile(path.dirname(id), ts$1.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);
+	tsconfigCache.set(configPath, configContents.options);
+	return configContents.options;
+}
+
 //#endregion
 //#region src/generate.ts
 const meta = { dtsFile: true };
-function createGeneratePlugin({ isolatedDeclaration: isolatedDeclaration$1, inputAlias = {}, resolve = false }) {
+function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDeclaration$1, inputAlias, resolve = false, emitDtsOnly = false }) {
 	const dtsMap = new Map();
-	const inputAliasMap = new Map(Object.entries(inputAlias));
+	const inputAliasMap = new Map(inputAlias && Object.entries(inputAlias));
 	const resolver = createResolver();
+	let programs = [];
 	let inputOption;
 	return {
 		name: "rolldown-plugin-dts:generate",
+		buildStart(options) {
+			if (isolatedDeclaration$1 == null) {
+				const { config } = getTsconfig(options.cwd) || {};
+				if (config?.compilerOptions?.isolatedDeclarations) isolatedDeclaration$1 = { stripInternal: !!config?.compilerOptions.stripInternal };
+			}
+		},
 		options({ input }) {
 			if (isPlainObject(input)) inputOption = { ...input };
 		},
+		outputOptions(options) {
+			return {
+				...options,
+				entryFileNames(chunk) {
+					const original = (typeof options.entryFileNames === "function" ? options.entryFileNames(chunk) : options.entryFileNames) || "[name].js";
+					if (chunk.name.endsWith(".d")) return original.replace(RE_JS, ".$1ts");
+					return original;
+				}
+			};
+		},
 		transform: {
 			order: "pre",
 			filter: { id: {
@@ -453,20 +556,44 @@ function createGeneratePlugin({ isolatedDeclaration: isolatedDeclaration$1, inpu
 				exclude: [RE_DTS, RE_NODE_MODULES]
 			} },
 			handler(code, id) {
-				const { code: dtsCode, errors } = isolatedDeclaration(id, code, isolatedDeclaration$1);
-				if (errors.length) return this.error(errors[0]);
-				const dtsId = filename_ts_to_dts(id);
-				dtsMap.set(dtsId, dtsCode);
+				let dtsCode;
 				const mod = this.getModuleInfo(id);
-				if (mod?.isEntry) {
-					let fileName = basename(dtsId);
-					if (inputAliasMap.has(fileName)) fileName = inputAliasMap.get(fileName);
-					else if (inputAliasMap.has(dtsId)) fileName = inputAliasMap.get(dtsId);
+				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]);
+					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));
+				}
+				if (!dtsCode) return this.error(new Error(`Failed to generate dts for ${id}`));
+				const dtsId = filename_ts_to_dts(id);
+				dtsMap.set(dtsId, {
+					code: dtsCode,
+					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);
 					this.emitFile({
 						type: "chunk",
 						id: dtsId,
-						fileName
+						name
 					});
+					if (emitDtsOnly) return "//";
 				}
 			}
 		},
@@ -523,10 +650,16 @@ function createGeneratePlugin({ isolatedDeclaration: isolatedDeclaration$1, inpu
 			} },
 			handler(id) {
 				if (dtsMap.has(id)) return {
-					code: dtsMap.get(id),
+					code: dtsMap.get(id).code,
 					moduleSideEffects: false
 				};
 			}
+		},
+		generateBundle: emitDtsOnly ? (options, bundle) => {
+			for (const fileName of Object.keys(bundle)) if (!RE_DTS.test(fileName)) delete bundle[fileName];
+		} : void 0,
+		buildEnd() {
+			programs = [];
 		}
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A Rolldown plugin to bundle dts files",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,17 @@
     "access": "public"
   },
   "peerDependencies": {
-    "rolldown": "^1.0.0-beta.7"
+    "rolldown": "^1.0.0-beta.7",
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "dependencies": {
     "dts-resolver": "^0.1.0",
+    "get-tsconfig": "^4.10.0",
     "magic-string-ast": "^0.9.1",
     "oxc-parser": "^0.62.0",
     "oxc-transform": "^0.62.0"