rolldown-plugin-dts 0.0.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2025 三咲智子 Kevin Deng (https://github.com/sxzz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# rolldown-plugin-dts [![npm](https://img.shields.io/npm/v/rolldown-plugin-dts.svg)](https://npmjs.com/package/rolldown-plugin-dts)
+
+[![Unit Test](https://github.com/sxzz/rolldown-plugin-dts/actions/workflows/unit-test.yml/badge.svg)](https://github.com/sxzz/rolldown-plugin-dts/actions/workflows/unit-test.yml)
+
+A Rolldown plugin to generate and bundle dts files.
+
+## Install
+
+```bash
+npm i rolldown-plugin-dts
+```
+
+## Usage
+
+Add the plugin to your `rolldown.config.js`:
+
+```js
+// rolldown.config.js
+import { dts } from 'rolldown-plugin-dts'
+
+export default {
+  input: './src/index.ts',
+  plugins: [dts()],
+  output: [{ dir: 'dist', format: 'es' }],
+}
+```
+
+You can find a real demo in [here](./rolldown.config.ts).
+
+## Options
+
+````ts
+interface Options {
+  /**
+   * When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
+   *
+   * If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
+   */
+  dtsInput?: boolean
+
+  isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, 'sourcemap'>
+
+  /**
+   * dts file name alias `{ [filename]: path }`
+   *
+   * @example
+   * ```ts
+   * inputAlias: {
+   *   'foo.d.ts': 'foo/index.d.ts',
+   * }
+   */
+  inputAlias?: Record<string, string>
+
+  /**
+   * Determines whether the module imported by `.d.ts` files should be treated as external or not.
+   */
+  external?: (
+    id: string,
+    importer: string,
+    extraOptions: ResolveIdExtraOptions,
+  ) => boolean | void
+}
+````
+
+## 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.
+
+- Namespaces are not supported yet.
+  - `export * as ns from './ns'`
+  - `import * as ns from './ns'` and then `export { ns }`
+  - `type ns = import('./ns')`
+
+## Credits
+
+The project is inspired by [rollup-plugin-dts](https://github.com/Swatinem/rollup-plugin-dts)
+but has been independently implemented.
+We extend our gratitude to the original creators for their contributions.
+Furthermore, the test suite is authorized by them and distributed under the MIT license.
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/sxzz/sponsors/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/sxzz/sponsors/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+[MIT](./LICENSE) License © 2025 [三咲智子 Kevin Deng](https://github.com/sxzz)

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { IsolatedDeclarationsOptions } from "oxc-transform";
+import { FunctionPluginHooks, Plugin } from "rolldown";
+
+//#region src/fake-js.d.ts
+declare function createFakeJsPlugin({ dtsInput }: Pick<Options, "dtsInput">): Plugin;
+
+//#endregion
+//#region src/generate.d.ts
+declare function createGeneratePlugin({ isolatedDeclaration, inputAlias, external }: Pick<Options, "external" | "isolatedDeclaration" | "inputAlias">): Plugin;
+
+//#endregion
+//#region src/index.d.ts
+type ResolveIdExtraOptions = Parameters<FunctionPluginHooks["resolveId"]>[2];
+interface Options {
+	/**
+	* When entries are `.d.ts` files (instead of `.ts` files), this option should be set to `true`.
+	*
+	* If enabled, the plugin will skip generating a `.d.ts` file for the entry point.
+	*/
+	dtsInput?: boolean;
+	isolatedDeclaration?: Omit<IsolatedDeclarationsOptions, "sourcemap">;
+	/**
+	* dts file name alias `{ [filename]: path }`
+	*
+	* @example
+	* ```ts
+	* inputAlias: {
+	*   'foo.d.ts': 'foo/index.d.ts',
+	* }
+	*/
+	inputAlias?: Record<string, string>;
+	/**
+	* Determines whether the module imported by `.d.ts` files should be treated as external or not.
+	*/
+	external?: (id: string, importer: string, extraOptions: ResolveIdExtraOptions) => boolean | void;
+}
+declare function dts(options?: Options): Plugin[];
+
+//#endregion
+export { Options, createFakeJsPlugin, createGeneratePlugin, dts };

package/dist/index.js

@@ -0,0 +1,516 @@
+import { MagicStringAST } from "magic-string-ast";
+import { parseAsync } from "oxc-parser";
+import path, { basename } from "node:path";
+import { isolatedDeclaration } from "oxc-transform";
+
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+//#endregion
+//#region node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+function walk(ast, { enter, leave }) {
+	const instance = new SyncWalker(enter, leave);
+	return instance.visit(ast, null);
+}
+
+//#endregion
+//#region src/utils/ast.ts
+function getIdentifierRange(node, offset = 0) {
+	if ("typeAnnotation" in node && node.typeAnnotation) return [node.start + offset, node.typeAnnotation.start + offset];
+	return [node.start + offset, node.end + offset];
+}
+
+//#endregion
+//#region src/utils/filename.ts
+const RE_JS = /\.([cm]?)js$/;
+const RE_TS = /\.([cm]?)ts$/;
+const RE_DTS = /\.d\.([cm]?)ts$/;
+const RE_NODE_MODULES = /node_modules/;
+function filename_js_to_dts(id) {
+	return id.replace(RE_JS, ".d.$1ts");
+}
+function filename_ts_to_dts(id) {
+	return id.replace(RE_TS, ".d.$1ts");
+}
+function filename_dts_to(id, ext) {
+	return id.replace(RE_DTS, `.$1${ext}`);
+}
+function isRelative(id) {
+	return path.isAbsolute(id) || id[0] === ".";
+}
+
+//#endregion
+//#region src/utils/magic-string.ts
+function overwriteOrAppend(s, range, replacement, suffix) {
+	if (range[0] === range[1]) {
+		s.appendLeft(range[0], ` ${replacement}`);
+		return;
+	}
+	const original = s.slice(range[0], range[1]);
+	if (original !== replacement) s.overwrite(range[0], range[1], replacement + (suffix || ""));
+}
+
+//#endregion
+//#region src/fake-js.ts
+const RE_TYPE = /\btype\b/;
+function createFakeJsPlugin({ dtsInput }) {
+	let symbolIdx = 0;
+	let identifierIdx = 0;
+	const symbolMap = new Map();
+	const preserveMap = new Map();
+	function getIdentifierIndex() {
+		return identifierIdx++;
+	}
+	function register(info) {
+		const symbolId = symbolIdx++;
+		symbolMap.set(symbolId, info);
+		return symbolId;
+	}
+	function retrieve(symbolId) {
+		return symbolMap.get(symbolId);
+	}
+	return {
+		name: "rolldown-plugin-dts:fake-js",
+		options: dtsInput ? (options) => {
+			return {
+				...options,
+				resolve: {
+					extensions: [
+						".d.ts",
+						".d.mts",
+						".d.cts"
+					],
+					extensionAlias: {
+						".js": [".d.ts"],
+						".mjs": [".d.mts"],
+						".cjs": [".d.cts"]
+					},
+					...options.resolve
+				}
+			};
+		} : void 0,
+		outputOptions(options) {
+			return {
+				...options,
+				entryFileNames: options.entryFileNames ?? (dtsInput ? "[name].ts" : void 0),
+				chunkFileNames(chunk) {
+					const original = (typeof options.chunkFileNames === "function" ? options.chunkFileNames(chunk) : options.chunkFileNames) || "[name]-[hash].js";
+					if (chunk.name.endsWith(".d")) return filename_js_to_dts(original);
+					return original;
+				}
+			};
+		},
+		transform: {
+			filter: { id: {
+				include: [RE_DTS],
+				exclude: [RE_NODE_MODULES]
+			} },
+			async handler(code, id) {
+				const { program, comments } = await parseAsync(id, code);
+				const preserved = collectReferenceDirectives(comments);
+				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;
+					const isDefaultExport = node.type === "ExportDefaultDeclaration";
+					if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && node.declaration) node = node.declaration;
+					if (node.type === "VariableDeclaration" && node.declarations.length !== 1) throw new Error("Only one declaration is supported");
+					if (node.type === "TSDeclareFunction" || node.type.endsWith("Declaration")) {
+						const binding = node.type === "VariableDeclaration" ? node.declarations[0].id : node.id;
+						const code$1 = s.sliceNode(node);
+						const jsdoc = comments.find((c) => c.type === "Block" && c.value[0] === "*" && c.start < node.start && stmt.start - c.end <= 1);
+						const offset = node.start;
+						let bindingRange;
+						if (sideEffect) bindingRange = [0, 0];
+						else if (binding) bindingRange = getIdentifierRange(binding, -offset);
+						else if (isDefaultExport) {
+							const idx = s.sliceNode(node).indexOf("function") + 8;
+							bindingRange = [idx, idx];
+						} else continue;
+						const depsNodes = collectDependencies(s, node, getIdentifierIndex);
+						const depsString = stringifyDependencies(s, depsNodes);
+						const depsSymbols = depsNodes.map((dep) => [
+							dep.start - offset,
+							dep.end - offset,
+							dep._suffix
+						]);
+						const needDeclare = (node.type === "TSEnumDeclaration" || node.type === "ClassDeclaration" || node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction" || node.type === "TSModuleDeclaration" || node.type === "VariableDeclaration") && !node.declare;
+						const symbolId = register({
+							code: code$1,
+							binding: bindingRange,
+							deps: depsSymbols,
+							needDeclare,
+							jsdoc: jsdoc ? s.sliceNode(jsdoc) : void 0,
+							preserveName: sideEffect
+						});
+						const runtime = `[${symbolId}, ${depsString}${depsString && sideEffect ? ", " : ""}${sideEffect ? "sideEffect()" : ""}]`;
+						const bindingName = sideEffect ? `_${identifierIdx++}` : binding ? s.sliceNode(binding) : "export_default";
+						if (isDefaultExport) s.overwriteNode(stmt, `var ${bindingName} = ${runtime};export { ${bindingName} as default }`);
+						else s.overwriteNode(node, `var ${bindingName} = ${runtime};`);
+					}
+				}
+				if (!s.hasChanged()) return;
+				const str = s.toString();
+				return str;
+			}
+		},
+		async renderChunk(code, chunk) {
+			if (!RE_DTS.test(chunk.fileName)) return;
+			const { program } = await parseAsync(chunk.fileName, code);
+			const s = new MagicStringAST(code);
+			const comments = new Set();
+			for (const id of chunk.moduleIds) {
+				const preserveComments = preserveMap.get(id);
+				if (preserveComments) {
+					preserveComments.forEach((c) => comments.add(c));
+					preserveMap.delete(id);
+				}
+			}
+			if (comments.size) s.prepend(`${[...comments].join("\n")}\n`);
+			for (const node of program.body) {
+				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);
+					continue;
+				}
+				const [symbolIdNode, ...depsNodes] = decl.init.elements;
+				if (symbolIdNode?.type !== "Literal" || typeof symbolIdNode.value !== "number") {
+					patchVariableDeclarator(s, node, decl);
+					continue;
+				}
+				const symbolId = symbolIdNode.value;
+				const { code: code$1, binding, deps, needDeclare, jsdoc, preserveName } = retrieve(symbolId);
+				const depsRaw = depsNodes.filter((node$1) => node$1?.type === "ArrowFunctionExpression").map((dep) => s.sliceNode(dep.body));
+				const ss = new MagicStringAST(code$1);
+				if (!preserveName) overwriteOrAppend(ss, binding, s.sliceNode(decl.id));
+				for (const dep of deps) {
+					const [start, end, suffix] = dep;
+					overwriteOrAppend(ss, [start, end], depsRaw.shift(), suffix);
+				}
+				if (needDeclare) ss.prepend("declare ");
+				if (jsdoc) ss.prepend(`${jsdoc}\n`);
+				s.overwriteNode(node, ss.toString());
+			}
+			const str = s.toString();
+			if (str.trim().length === 0) return "export {}";
+			return str;
+		}
+	};
+}
+const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
+function collectReferenceDirectives(comment) {
+	return comment.filter((c) => REFERENCE_RE.test(c.value)).map((c) => `//${c.value}`);
+}
+function collectDependencies(s, node, getIdentifierIndex) {
+	const deps = new Set();
+	walk(node, { leave(node$1) {
+		if (node$1.type === "ExportNamedDeclaration") {
+			for (const specifier of node$1.specifiers) if (specifier.type === "ExportSpecifier") {
+				let _suffix;
+				if (specifier.local.start === specifier.exported.start && specifier.local.end === specifier.exported.end) _suffix = ` as ${s.sliceNode(specifier.local)}`;
+				addDependency({
+					...specifier.local,
+					_suffix
+				});
+			}
+		} else if (node$1.type === "TSInterfaceDeclaration" && node$1.extends) for (const heritage of node$1.extends || []) addDependency(heritage.expression);
+		else if (node$1.type === "ClassDeclaration") {
+			if (node$1.superClass) addDependency(node$1.superClass);
+			if (node$1.implements) for (const implement of node$1.implements) addDependency(implement.expression);
+		} else if (node$1.type === "MethodDefinition" || node$1.type === "PropertyDefinition" || node$1.type === "TSPropertySignature") {
+			if (node$1.computed && isReferenceId(node$1.key)) addDependency(node$1.key);
+			if ("value" in node$1 && isReferenceId(node$1.value)) addDependency(node$1.value);
+		} else if (node$1.type === "TSTypeReference") addDependency(node$1.typeName);
+		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 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
+			});
+		}
+	} });
+	return Array.from(deps);
+	function addDependency(node$1) {
+		if (node$1.type === "Identifier" && node$1.name === "this") return;
+		deps.add(node$1);
+	}
+}
+function isReferenceId(node) {
+	return !!node && (node.type === "Identifier" || node.type === "MemberExpression");
+}
+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 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, ""));
+		const firstSpecifier = node.specifiers[0];
+		const kind = node.type === "ImportDeclaration" ? node.importKind : node.exportKind;
+		if (kind === "type" && firstSpecifier) s.overwrite(node.start, firstSpecifier.start, s.slice(node.start, firstSpecifier.start).replace(RE_TYPE, ""));
+		return true;
+	} else if (node.type === "ExportAllDeclaration") {
+		if (node.exportKind === "type") s.overwrite(node.start, node.source.start, s.slice(node.start, node.source.start).replace(RE_TYPE, ""));
+		return true;
+	} else if (node.type === "TSImportEqualsDeclaration") {
+		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)}`);
+		return true;
+	} else if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
+		s.overwriteNode(node, `export { ${s.sliceNode(node.declaration)} as default }`);
+		return true;
+	}
+}
+function importNamespace(s, source, imported, getIdentifierIndex) {
+	const local = `_${getIdentifierIndex()}`;
+	s.prepend(`import { ${imported} as ${local} } from ${JSON.stringify(source)};\n`);
+	return local;
+}
+
+//#endregion
+//#region src/generate.ts
+function createGeneratePlugin({ isolatedDeclaration: isolatedDeclaration$1, inputAlias, external }) {
+	const dtsMap = new Map();
+	return {
+		name: "rolldown-plugin-dts:generate",
+		transform: {
+			order: "pre",
+			filter: { id: {
+				include: [RE_TS],
+				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);
+				const mod = this.getModuleInfo(id);
+				if (mod?.isEntry) {
+					let fileName = basename(dtsId);
+					if (inputAlias?.[fileName]) fileName = inputAlias[fileName];
+					this.emitFile({
+						type: "chunk",
+						id: dtsId,
+						fileName
+					});
+				}
+			}
+		},
+		async resolveId(id, importer, extraOptions) {
+			if (dtsMap.has(id)) return {
+				id,
+				meta: { dtsFile: true }
+			};
+			const importerMod = importer ? this.getModuleInfo(importer) : null;
+			if (importerMod?.meta.dtsFile) {
+				if (!isRelative(id) || external?.(id, importer, extraOptions) === true) return {
+					id,
+					external: true
+				};
+				const resolution = await this.resolve(id, filename_dts_to(importer, "ts"));
+				if (!resolution || resolution.external) return;
+				const dtsId = filename_ts_to_dts(resolution.id);
+				if (dtsMap.has(dtsId)) return {
+					id: dtsId,
+					meta: { dtsFile: true }
+				};
+				await this.load(resolution);
+				if (dtsMap.has(dtsId)) return {
+					id: dtsId,
+					meta: { dtsFile: true }
+				};
+			}
+		},
+		load: {
+			filter: { id: {
+				include: [RE_DTS],
+				exclude: [RE_NODE_MODULES]
+			} },
+			handler(id) {
+				if (dtsMap.has(id)) return {
+					code: dtsMap.get(id),
+					moduleSideEffects: false
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+function dts(options = {}) {
+	const plugins = [];
+	if (!options.dtsInput) plugins.push(createGeneratePlugin(options));
+	plugins.push(createFakeJsPlugin(options));
+	return plugins;
+}
+
+//#endregion
+export { createFakeJsPlugin, createGeneratePlugin, dts };

package/package.json

@@ -1,12 +1,67 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "version": "0.2.0",
+  "description": "A Rolldown plugin to bundle dts files",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/sxzz/rolldown-plugin-dts#readme",
+  "bugs": {
+    "url": "https://github.com/sxzz/rolldown-plugin-dts/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sxzz/rolldown-plugin-dts.git"
+  },
+  "author": "三咲智子 Kevin Deng <sxzz@sxzz.moe>",
+  "funding": "https://github.com/sponsors/sxzz",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "magic-string-ast": "^0.9.1",
+    "oxc-parser": "^0.62.0",
+    "oxc-transform": "^0.62.0"
+  },
+  "devDependencies": {
+    "@sxzz/eslint-config": "^6.1.1",
+    "@sxzz/prettier-config": "^2.2.1",
+    "@sxzz/test-utils": "^0.5.4",
+    "@types/diff": "^7.0.2",
+    "@types/node": "^22.14.0",
+    "bumpp": "^10.1.0",
+    "diff": "^7.0.0",
+    "eslint": "^9.24.0",
+    "estree-walker": "^3.0.3",
+    "prettier": "^3.5.3",
+    "rolldown": "1.0.0-beta.7",
+    "rollup-plugin-dts": "^6.2.1",
+    "tsdown": "^0.8.0-beta.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "prettier": "@sxzz/prettier-config",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "lint": "eslint --cache .",
+    "lint:fix": "pnpm run lint --fix",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --cache --write .",
+    "release": "bumpp && pnpm publish"
   }
 }

package/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "cSpell.words": [
-        "rolldown"
-    ]
-}