rolldown-plugin-dts 0.0.0 → 0.1.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,57 @@
+# 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 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'
+
+const config = [
+  {
+    input: './index.d.ts',
+    plugins: [dts()],
+    output: [
+      {
+        file: 'dist/index.d.ts',
+        format: 'es',
+      },
+    ],
+  },
+]
+
+export default config
+```
+
+> [!NOTE]
+> Namespaces are not supported yet.
+
+## 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,7 @@
+import { Plugin } from "rolldown";
+
+//#region dist/.tsdown-types-es/index.d.ts
+declare function dts(): Plugin;
+
+//#endregion
+export { dts };

package/dist/index.js

@@ -0,0 +1,404 @@
+import path from "node:path";
+import { MagicStringAST } from "magic-string-ast";
+import { parseAsync } from "oxc-parser";
+
+//#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$1 = 0; i$1 < nodes.length; i$1 += 1) {
+							const item = nodes[i$1];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i$1)) i$1--;
+							}
+						}
+					} 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/magic-string.ts
+function overwriteOrAppend(s, range, replacement) {
+	if (range[0] === range[1]) {
+		s.appendLeft(range[0], ` ${replacement}`);
+		return;
+	}
+	s.overwrite(range[0], range[1], replacement);
+}
+
+//#endregion
+//#region src/index.ts
+const RE_TYPE = /\btype\b/;
+function dts() {
+	let i$1 = 0;
+	const symbolMap = new Map();
+	const commentMap = new Map();
+	function register(info) {
+		const symbolId = i$1++;
+		symbolMap.set(symbolId, info);
+		return symbolId;
+	}
+	function retrieve(symbolId) {
+		return symbolMap.get(symbolId);
+	}
+	return {
+		name: "rolldown-plugin-dts",
+		options({ onLog,...options }) {
+			return {
+				...options,
+				resolve: {
+					extensions: [
+						".d.ts",
+						".d.mts",
+						".d.cts"
+					],
+					extensionAlias: {
+						".js": [".d.ts"],
+						".mjs": [".d.mts"],
+						".cjs": [".d.cts"]
+					},
+					...options.resolve
+				},
+				onLog(level, log, defaultHandler) {
+					if (level === "warn" && log.code === "CIRCULAR_DEPENDENCY") return;
+					if (onLog) onLog(level, log, defaultHandler);
+					else defaultHandler(level, log);
+				},
+				treeshake: {
+					moduleSideEffects: "no-external",
+					unknownGlobalSideEffects: false
+				}
+			};
+		},
+		outputOptions(options) {
+			return {
+				chunkFileNames: "[name]-[hash].d.ts",
+				entryFileNames: "[name].ts",
+				format: "es",
+				exports: "named",
+				...options
+			};
+		},
+		resolveId(id, importer) {
+			if (importer && !path.isAbsolute(id) && id[0] !== ".") return {
+				id,
+				external: true
+			};
+		},
+		async transform(code, id) {
+			const { program, comments } = await parseAsync(id, code);
+			const preserveComments = collectReferenceDirectives(comments);
+			commentMap.set(id, preserveComments);
+			const s = new MagicStringAST(code);
+			for (let node of program.body) {
+				if (rewriteImportExport(s, node)) continue;
+				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] === "*" && stmt.start - c.end <= 1);
+					const offset = node.start;
+					let bindingRange;
+					if (binding) bindingRange = getIdentifierRange(binding, -offset);
+					else if (isDefaultExport) {
+						const idx = s.sliceNode(node).indexOf("function") + 8;
+						bindingRange = [idx, idx];
+					} else continue;
+					const deps = collectDependencies(s, node);
+					const depsString = stringifyDependencies(s, deps);
+					const depsRanges = deps.map((dep) => [dep.start - offset, dep.end - offset]);
+					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: depsRanges,
+						needDeclare,
+						jsdoc: jsdoc ? s.sliceNode(jsdoc) : void 0
+					});
+					const runtime = `[${symbolId}, ${depsString}]`;
+					const bindingName = binding ? s.sliceNode(binding) : "export_default";
+					if (isDefaultExport) s.overwriteNode(stmt, `var ${bindingName} = ${runtime};export { ${bindingName} as default }`);
+					else s.overwriteNode(node, `var ${bindingName} = [${symbolId}, ${depsString}]`);
+				}
+			}
+			if (!s.hasChanged()) return;
+			const str = s.toString();
+			return str;
+		},
+		async renderChunk(code, chunk) {
+			const { program } = await parseAsync(chunk.fileName, code);
+			const s = new MagicStringAST(code);
+			const comments = new Set();
+			for (const id of chunk.moduleIds) {
+				const preserveComments = commentMap.get(id);
+				if (preserveComments) {
+					preserveComments.forEach((c) => comments.add(c));
+					commentMap.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 } = retrieve(symbolId);
+				const depsRaw = depsNodes.map((dep) => {
+					if (dep.type !== "ArrowFunctionExpression") throw new Error("Expected ArrowFunctionExpression");
+					return s.sliceNode(dep.body);
+				});
+				const ss = new MagicStringAST(code$1);
+				overwriteOrAppend(ss, binding, s.sliceNode(decl.id));
+				for (const dep of deps) overwriteOrAppend(ss, dep, depsRaw.shift());
+				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) {
+	const deps = new Set();
+	walk(node, { leave(node$1) {
+		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);
+			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 ");
+}
+const RE_D_TS = /\.d\.([cm]?)ts$/;
+function patchImportSource(s, node) {
+	if ((node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") && node.source?.value && RE_D_TS.test(node.source.value)) {
+		s.overwriteNode(node.source, JSON.stringify(node.source.value.replace(RE_D_TS, ".$1js")));
+		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;
+	}
+}
+let i = 0;
+function importNamespace(s, source, imported) {
+	const local = `_${i++}`;
+	s.prepend(`import { ${imported} as ${local} } from ${JSON.stringify(source)};\n`);
+	return local;
+}
+
+//#endregion
+export { dts };

package/package.json

@@ -1,12 +1,66 @@
 {
   "name": "rolldown-plugin-dts",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "version": "0.1.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"
+  },
+  "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.13.17",
+    "bumpp": "^10.1.0",
+    "diff": "^7.0.0",
+    "eslint": "^9.23.0",
+    "estree-walker": "^3.0.3",
+    "prettier": "^3.5.3",
+    "rolldown": "1.0.0-beta.7",
+    "rollup-plugin-dts": "^6.2.1",
+    "tsdown": "^0.7.3",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "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"
-    ]
-}