rolldown-plugin-dts 0.4.0 → 0.5.1

package/README.md

@@ -45,8 +45,19 @@ interface Options {
    */
   emitDtsOnly?: boolean
 
-  isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, 'sourcemap'>
-
+  /**
+   * 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 }`
    *
@@ -65,14 +76,24 @@ interface Options {
 
 ## ⚠️ 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, emitDtsOnly }: Pick<Options, "isolatedDeclaration" | "inputAlias" | "resolve" | "emitDtsOnly">): Plugin;
+declare function createGeneratePlugin({ compilerOptions, isolatedDeclaration, inputAlias, resolve, emitDtsOnly }: Pick<Options, "isolatedDeclaration" | "inputAlias" | "resolve" | "emitDtsOnly" | "compilerOptions">): Plugin;
 
 //#endregion
 //#region src/index.d.ts
@@ -23,7 +24,19 @@ interface Options {
 	* 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;
-	isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, "sourcemap">;
+	/**
+	* 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 { parseSync } from "oxc-parser";
 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";
 
 //#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
 var WalkerBase = class {
@@ -248,8 +251,8 @@ function createFakeJsPlugin({ dtsInput }) {
 		},
 		transform: {
 			filter: { id: RE_DTS },
-			async handler(code, id) {
-				const { program, comments } = await parseAsync(id, code);
+			handler(code, id) {
+				const { program, comments } = parseSync(id, code);
 				const preserved = collectReferenceDirectives(comments);
 				preserveMap.set(id, preserved);
 				const s = new MagicStringAST(code);
@@ -300,9 +303,9 @@ function createFakeJsPlugin({ dtsInput }) {
 				return str;
 			}
 		},
-		async renderChunk(code, chunk) {
+		renderChunk(code, chunk) {
 			if (!RE_DTS.test(chunk.fileName)) return;
-			const { program } = await parseAsync(chunk.fileName, code);
+			const { program } = parseSync(chunk.fileName, code);
 			const s = new MagicStringAST(code);
 			const comments = new Set();
 			for (const id of chunk.moduleIds) {
@@ -433,16 +436,113 @@ function importNamespace(s, source, imported, getIdentifierIndex) {
 	return local;
 }
 
+//#endregion
+//#region src/utils/tsc.ts
+let ts$1;
+let formatHost;
+function initTs() {
+	const require = createRequire(import.meta.url);
+	ts$1 = require("typescript");
+	formatHost = {
+		getCurrentDirectory: () => ts$1.sys.getCurrentDirectory(),
+		getNewLine: () => ts$1.sys.newLine,
+		getCanonicalFileName: ts$1.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+	};
+}
+const defaultCompilerOptions = {
+	declaration: true,
+	noEmit: false,
+	emitDeclarationOnly: true,
+	noEmitOnError: true,
+	checkJs: false,
+	declarationMap: false,
+	skipLibCheck: true,
+	preserveSymlinks: true,
+	target: 99,
+	resolveJsonModule: true
+};
+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, emitDtsOnly = false }) {
+function createGeneratePlugin({ compilerOptions, isolatedDeclaration: isolatedDeclaration$1, inputAlias, resolve = false, emitDtsOnly = false }) {
 	const dtsMap = new Map();
 	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 };
+			}
+			if (!isolatedDeclaration$1) initTs();
+		},
 		options({ input }) {
 			if (isPlainObject(input)) inputOption = { ...input };
 		},
@@ -463,15 +563,35 @@ 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]);
+				let dtsCode;
+				const mod = this.getModuleInfo(id);
+				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
 				});
-				const mod = this.getModuleInfo(id);
-				if (mod?.isEntry) {
+				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);
@@ -544,7 +664,10 @@ function createGeneratePlugin({ isolatedDeclaration: isolatedDeclaration$1, inpu
 		},
 		generateBundle: emitDtsOnly ? (options, bundle) => {
 			for (const fileName of Object.keys(bundle)) if (!RE_DTS.test(fileName)) delete bundle[fileName];
-		} : void 0
+		} : void 0,
+		buildEnd() {
+			programs = [];
+		}
 	};
 }
 function isPlainObject(data) {

package/package.json

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