fumadocs-typescript 5.1.1 → 5.1.3

package/dist/{base-Dvhn4vZx.d.ts → base-CLqyTLv7.d.ts}

@@ -1,14 +1,5 @@
 import { ExportedDeclarations, Project, Symbol, Type } from "ts-morph";
 
-//#region src/create-project.d.ts
-interface TypescriptConfig {
-  files?: string[];
-  tsconfigPath?: string;
-  /** A root directory to resolve relative path entries in the config file to. e.g. outDir */
-  basePath?: string;
-}
-declare function createProject(options?: TypescriptConfig): Project;
-//#endregion
 //#region src/lib/type-table.d.ts
 interface BaseTypeTableProps {
   /**
@@ -51,20 +42,26 @@ interface GenerateTypeTableOptions extends GenerateOptions {
 //#endregion
 //#region src/cache/index.d.ts
 interface Cache {
-  read: (key: string) => unknown | undefined | Promise<unknown | undefined>;
-  write: (key: string, value: unknown) => void | Promise<void>;
+  read: (hash: string) => unknown | undefined | Promise<unknown | undefined>;
+  write: (hash: string, value: unknown) => void | Promise<void>;
 }
+declare function generateHash(str: string): string;
 //#endregion
 //#region src/lib/base.d.ts
 interface GeneratedDoc {
+  /**
+   * unique ID generated from file name & export declaration.
+   */
+  id: string;
   name: string;
-  description: string;
+  description?: string;
   entries: DocEntry[];
 }
 interface DocEntry {
   name: string;
   description: string;
   type: string;
+  typeHref?: string;
   simplifiedType: string;
   tags: RawTag[];
   required: boolean;
@@ -74,9 +71,8 @@ interface RawTag {
   name: string;
   text: string;
 }
-interface EntryContext {
+interface EntryContext extends GenerateOptions {
   program: Project;
-  transform?: Transformer;
   type: Type;
   declaration: ExportedDeclarations;
 }
@@ -103,7 +99,11 @@ interface GeneratorOptions extends TypescriptConfig {
   cache?: Cache | false;
   project?: Project;
 }
-declare function createGenerator(config?: GeneratorOptions | Project): {
+interface TypescriptConfig {
+  tsconfigPath?: string;
+}
+declare function createProject(options?: TypescriptConfig): Promise<Project>;
+declare function createGenerator(options?: GeneratorOptions): {
   generateDocumentation(file: {
     path: string;
     content?: string;
@@ -111,4 +111,4 @@ declare function createGenerator(config?: GeneratorOptions | Project): {
   generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions): Promise<GeneratedDoc[]>;
 };
 //#endregion
-export { GeneratorOptions as a, Cache as c, createProject as d, Generator as i, BaseTypeTableProps as l, GenerateOptions as n, RawTag as o, GeneratedDoc as r, createGenerator as s, DocEntry as t, GenerateTypeTableOptions as u };
+export { GeneratorOptions as a, createGenerator as c, generateHash as d, BaseTypeTableProps as f, Generator as i, createProject as l, GenerateOptions as n, RawTag as o, GenerateTypeTableOptions as p, GeneratedDoc as r, TypescriptConfig as s, DocEntry as t, Cache as u };

package/dist/get-simple-form-B8HWDNe0.js

@@ -0,0 +1,45 @@
+import { TypeFormatFlags } from "ts-morph";
+
+//#region src/lib/get-simple-form.ts
+function getSimpleForm(type, checker, noUndefined = false, location) {
+	if (type.isUndefined() && noUndefined) return "";
+	const alias = type.getAliasSymbol();
+	if (alias) {
+		const args = type.getAliasTypeArguments();
+		if (args.length === 0) return alias.getName();
+		return `${alias.getName()}<${args.map((arg) => getSimpleForm(arg, checker)).join(", ")}>`;
+	}
+	if (type.isUnion()) {
+		const types = [];
+		for (const t of type.getUnionTypes()) {
+			const str = getSimpleForm(t, checker, noUndefined);
+			if (str.length > 0 && str !== "never") types.unshift(str);
+		}
+		return types.length > 0 ? dedupe(types).join(" | ").replace("true | false", "boolean") : "never";
+	}
+	if (type.isIntersection()) {
+		const types = [];
+		for (const t of type.getIntersectionTypes()) {
+			const str = getSimpleForm(t, checker, noUndefined);
+			if (str.length > 0 && str !== "never") types.unshift(str);
+		}
+		return dedupe(types).join(" & ");
+	}
+	if (type.isTuple()) return `[${type.getTupleElements().map((t) => getSimpleForm(t, checker)).join(", ")}]`;
+	if (type.isArray() || type.isReadonlyArray()) return "array";
+	if (type.getCallSignatures().length > 0) return "function";
+	if (type.isClassOrInterface() || type.isObject()) return "object";
+	return type.getText(location, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+}
+function dedupe(arr) {
+	const dedupe = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of arr) if (!dedupe.has(item)) {
+		out.push(item);
+		dedupe.add(item);
+	}
+	return out;
+}
+
+//#endregion
+export { getSimpleForm };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as GeneratorOptions, c as Cache, d as createProject, i as Generator, l as BaseTypeTableProps, n as GenerateOptions, o as RawTag, r as GeneratedDoc, s as createGenerator, t as DocEntry, u as GenerateTypeTableOptions } from "./base-Dvhn4vZx.js";
+import { a as GeneratorOptions, c as createGenerator, d as generateHash, f as BaseTypeTableProps, i as Generator, l as createProject, n as GenerateOptions, o as RawTag, p as GenerateTypeTableOptions, r as GeneratedDoc, s as TypescriptConfig, t as DocEntry, u as Cache } from "./base-CLqyTLv7.js";
 import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
 import { Nodes } from "hast";
 import { Root } from "mdast";
@@ -31,7 +31,7 @@ interface RemarkAutoTypeTableOptions {
    */
   options?: GenerateTypeTableOptions;
   /**
-   * generate required `value` property for `remark-stringify`
+   * generate the stringified form of props (useful for `remark-stringify` etc).
    */
   remarkStringify?: boolean;
   generator?: Generator;
@@ -49,4 +49,4 @@ declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions): Trans
 //#region src/cache/fs-cache.d.ts
 declare function createFileSystemGeneratorCache(dir: string): Cache;
 //#endregion
-export { Cache, DocEntry, GenerateOptions, GeneratedDoc, Generator, GeneratorOptions, type MarkdownRenderer, RawTag, RemarkAutoTypeTableOptions, TypeTableProps, createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };
+export { Cache, DocEntry, GenerateOptions, GeneratedDoc, Generator, GeneratorOptions, type MarkdownRenderer, RawTag, RemarkAutoTypeTableOptions, TypeTableProps, TypescriptConfig, createFileSystemGeneratorCache, createGenerator, createProject, generateHash, remarkAutoTypeTable };

package/dist/index.js

@@ -1,29 +1,17 @@
-import { n as markdownRenderer, t as parseTags } from "./parse-tags-B09hzgIX.js";
-import * as ts$1 from "ts-morph";
-import { Project, ts } from "ts-morph";
-import * as fs$1 from "node:fs/promises";
+import { n as markdownRenderer, t as parseTags } from "./parse-tags-D9KSwbHI.js";
 import fs from "node:fs/promises";
-import path, { join } from "node:path";
+import path from "node:path";
+import { createHash } from "node:crypto";
 import { valueToEstree } from "estree-util-value-to-estree";
 import { visit } from "unist-util-visit";
 import { toEstree } from "hast-util-to-estree";
-import { createHash } from "node:crypto";
 
-//#region src/create-project.ts
-function createProject(options = {}) {
-	return new Project({
-		tsConfigFilePath: options.tsconfigPath ?? "./tsconfig.json",
-		skipAddingFilesFromTsConfig: true
-	});
-}
-
-//#endregion
 //#region src/lib/type-table.ts
 async function getTypeTableOutput(gen, { name, type, ...props }, options) {
-	const file = props.path && options?.basePath ? join(options.basePath, props.path) : props.path;
+	const file = props.path && options?.basePath ? path.join(options.basePath, props.path) : props.path;
 	let typeName = name;
 	let content = "";
-	if (file) content = (await fs$1.readFile(file)).toString();
+	if (file) content = (await fs.readFile(file)).toString();
 	if (type && type.split("\n").length > 1) content += `\n${type}`;
 	else if (type) {
 		typeName ??= "$Fumadocs";
@@ -38,125 +26,136 @@ async function getTypeTableOutput(gen, { name, type, ...props }, options) {
 }
 
 //#endregion
-//#region src/lib/get-simple-form.ts
-function getSimpleForm(type, checker, noUndefined = false, location) {
-	if (type.isUndefined() && noUndefined) return "";
-	const alias = type.getAliasSymbol();
-	if (alias) {
-		const args = type.getAliasTypeArguments();
-		if (args.length === 0) return alias.getName();
-		return `${alias.getName()}<${args.map((arg) => getSimpleForm(arg, checker)).join(", ")}>`;
-	}
-	if (type.isUnion()) {
-		const types = [];
-		for (const t of type.getUnionTypes()) {
-			const str = getSimpleForm(t, checker, noUndefined);
-			if (str.length > 0 && str !== "never") types.unshift(str);
-		}
-		return types.length > 0 ? dedupe(types).join(" | ").replace("true | false", "boolean") : "never";
-	}
-	if (type.isIntersection()) {
-		const types = [];
-		for (const t of type.getIntersectionTypes()) {
-			const str = getSimpleForm(t, checker, noUndefined);
-			if (str.length > 0 && str !== "never") types.unshift(str);
-		}
-		return dedupe(types).join(" & ");
-	}
-	if (type.isTuple()) return `[${type.getTupleElements().map((t) => getSimpleForm(t, checker)).join(", ")}]`;
-	if (type.isArray() || type.isReadonlyArray()) return "array";
-	if (type.getCallSignatures().length > 0) return "function";
-	if (type.isClassOrInterface() || type.isObject()) return "object";
-	return type.getText(location, ts$1.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-}
-function dedupe(arr) {
-	const dedupe$1 = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const item of arr) if (!dedupe$1.has(item)) {
-		out.push(item);
-		dedupe$1.add(item);
-	}
-	return out;
+//#region src/cache/index.ts
+function generateHash(str) {
+	return createHash("SHA256").update(str).digest("hex").slice(0, 12);
 }
 
+//#endregion
+//#region package.json
+var version = "5.1.3";
+
 //#endregion
 //#region src/lib/base.ts
-function createGenerator(config) {
-	const options = config instanceof Project ? { project: config } : config;
+async function createProject(options = {}) {
+	const { Project } = await import("ts-morph");
+	return new Project({
+		tsConfigFilePath: options.tsconfigPath ?? "./tsconfig.json",
+		skipAddingFilesFromTsConfig: true
+	});
+}
+function createGenerator(options = {}) {
 	const cache = options?.cache ? options.cache : null;
-	let instance;
+	let instance = options?.project;
 	function getProject() {
-		instance ??= options?.project ?? createProject(options);
-		return instance;
+		if (instance) return instance;
+		return instance = createProject(options);
+	}
+	function getSourceFile(project, filePath, fileContent) {
+		const ext = path.extname(filePath);
+		const fileBase = filePath.slice(0, -ext.length);
+		let i = 0;
+		let sourceFile = project.getSourceFile(filePath);
+		while (sourceFile && sourceFile.getFullText() !== fileContent) {
+			filePath = `${fileBase}.${i++}${ext}`;
+			sourceFile = project.getSourceFile(filePath);
+		}
+		if (sourceFile) return sourceFile;
+		return project.createSourceFile(filePath, fileContent, { overwrite: true });
 	}
 	return {
-		async generateDocumentation(file, name, options$1) {
-			const content = file.content ?? (await fs.readFile(path.resolve(file.path))).toString();
-			const cacheKey = `${file.path}:${name}:${content}`;
+		async generateDocumentation(file, name, options = {}) {
+			const fullPath = path.resolve(file.path);
+			const content = file.content ?? (await fs.readFile(fullPath)).toString();
+			let cacheKey;
 			if (cache) {
+				cacheKey = generateHash(`${file.path}:${name}:${content}:${version}`);
 				const cached = await cache.read(cacheKey);
 				if (cached) return cached;
 			}
-			const sourceFile = getProject().createSourceFile(file.path, content, { overwrite: true });
+			const project = await getProject();
+			const sourceFile = getSourceFile(project, fullPath, content);
 			const out = [];
 			for (const [k, d] of sourceFile.getExportedDeclarations()) {
-				if (name && name !== k) continue;
+				if (d.length === 0 || !name || name !== k) continue;
 				if (d.length > 1) console.warn(`export ${k} should not have more than one type declaration.`);
-				out.push(generate(getProject(), k, d[0], options$1));
+				const declaration = d[0];
+				const entryContext = {
+					...options,
+					program: project,
+					type: declaration.getType(),
+					declaration
+				};
+				out.push(await generate(encodeURI(`${path.basename(file.path)}-${name}`), k, entryContext));
 			}
-			cache?.write(cacheKey, out);
+			if (cache && cacheKey) await cache.write(cacheKey, out);
 			return out;
 		},
-		generateTypeTable(props, options$1) {
-			return getTypeTableOutput(this, props, options$1);
+		generateTypeTable(props, options) {
+			return getTypeTableOutput(this, props, options);
 		}
 	};
 }
-function generate(program, name, declaration, { allowInternal = false, transform } = {}) {
-	const entryContext = {
-		transform,
-		program,
-		type: declaration.getType(),
-		declaration
-	};
+async function generate(id, name, entryContext) {
+	const { ts } = await import("ts-morph");
+	const { declaration, program } = entryContext;
 	const comment = declaration.getSymbol()?.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject);
+	const entries = [];
+	for (const prop of declaration.getType().getProperties()) {
+		const out = await getDocEntry(prop, entryContext);
+		if (out) entries.push(out);
+	}
 	return {
+		id,
 		name,
-		description: comment ? ts.displayPartsToString(comment) : "",
-		entries: declaration.getType().getProperties().map((prop) => getDocEntry(prop, entryContext)).filter((entry) => entry && (allowInternal || !("internal" in entry.tags)))
+		description: comment ? ts.displayPartsToString(comment) : void 0,
+		entries
 	};
 }
-function getDocEntry(prop, context) {
-	const { transform, program } = context;
+async function getDocEntry(prop, context) {
+	const { ts } = await import("ts-morph");
+	const { getSimpleForm } = await import("./get-simple-form-B8HWDNe0.js");
+	const { transform, allowInternal = false, program } = context;
 	if (context.type.isClass() && prop.getName().startsWith("#")) return;
 	const subType = prop.getTypeAtLocation(context.declaration);
 	const isOptional = prop.isOptional();
-	const tags = prop.getJsDocTags().map((tag) => ({
-		name: tag.getName(),
-		text: ts.displayPartsToString(tag.getText())
-	}));
-	let type = subType.getText(context.declaration, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation);
-	let simplifiedType = getSimpleForm(subType, program.getTypeChecker(), isOptional, context.declaration);
-	for (const tag of tags) {
-		if (tag.name === "fumadocsType") {
-			const match = /`(?<name>.+)`$/.exec(tag.text)?.[1];
-			if (match) type = match;
-			continue;
-		}
-		if (tag.name === "remarks") {
-			const match = /^`(?<name>.+)`/.exec(tag.text)?.[1];
-			if (match) simplifiedType = match;
-		}
+	const tags = [];
+	for (const tag of prop.getJsDocTags()) {
+		if (!allowInternal && tag.getName() === "internal") return;
+		tags.push({
+			name: tag.getName(),
+			text: ts.displayPartsToString(tag.getText())
+		});
 	}
 	const entry = {
 		name: prop.getName(),
 		description: ts.displayPartsToString(prop.compilerSymbol.getDocumentationComment(program.getTypeChecker().compilerObject)),
 		tags,
-		type,
-		simplifiedType,
+		type: subType.getText(context.declaration, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation),
+		simplifiedType: getSimpleForm(subType, program.getTypeChecker(), isOptional, context.declaration),
 		required: !isOptional,
-		deprecated: tags.some((tag) => tag.name === "deprecated")
+		deprecated: false
 	};
+	for (const tag of tags) switch (tag.name) {
+		case "fumadocsType": {
+			const match = /`(?<name>.+)`$/.exec(tag.text)?.[1];
+			if (match) entry.type = match;
+			break;
+		}
+		case "remarks": {
+			const match = /^`(?<name>.+)`/.exec(tag.text)?.[1];
+			if (match) entry.simplifiedType = match;
+			break;
+		}
+		case "fumadocsHref": {
+			const content = tag.text.trim();
+			if (content.length > 0) entry.typeHref = content;
+			break;
+		}
+		case "deprecated":
+			entry.deprecated = true;
+			break;
+	}
 	transform?.call(context, entry, subType, prop);
 	return entry;
 }
@@ -176,8 +175,8 @@ function objectBuilder() {
 				shorthand: false,
 				computed: false,
 				key: {
-					type: "Identifier",
-					name: key
+					type: "Literal",
+					value: key
 				},
 				kind: "init",
 				value: expression
@@ -199,6 +198,7 @@ async function buildTypeProp(entries, renderer) {
 		node.addJsxProperty("type", await renderer.renderTypeToHast(entry.simplifiedType));
 		node.addJsxProperty("typeDescription", await renderer.renderTypeToHast(entry.type));
 		node.addExpressionNode("required", valueToEstree(entry.required));
+		if (entry.typeHref) node.addExpressionNode("typeDescriptionLink", valueToEstree(entry.typeHref));
 		if (tags.default) node.addJsxProperty("default", await renderer.renderTypeToHast(tags.default));
 		if (tags.returns) node.addJsxProperty("returns", await renderer.renderMarkdownToHast(tags.returns));
 		if (tags.params) node.addExpressionNode("parameters", {
@@ -239,55 +239,79 @@ function remarkAutoTypeTable(config = {}) {
 		if (renderMarkdown) renderer.renderMarkdownToHast = renderMarkdown;
 		if (renderType) renderer.renderTypeToHast = renderType;
 	}
+	async function generate(file, props, attributes) {
+		let basePath = props.cwd ? file.cwd : generateOptions.basePath;
+		if (file.dirname) basePath ??= file.dirname;
+		const output = await generator.generateTypeTable(props, {
+			...generateOptions,
+			basePath
+		});
+		const rendered = [];
+		for (const doc of output) rendered.push({
+			type: "mdxJsxFlowElement",
+			name: outputName,
+			attributes: [
+				{
+					type: "mdxJsxAttribute",
+					name: "id",
+					value: `type-table-${doc.id}`
+				},
+				{
+					type: "mdxJsxAttribute",
+					name: "type",
+					value: {
+						type: "mdxJsxAttributeValueExpression",
+						value: remarkStringify ? JSON.stringify(doc, null, 2) : "",
+						data: { estree: {
+							type: "Program",
+							sourceType: "module",
+							body: [{
+								type: "ExpressionStatement",
+								expression: await buildTypeProp(doc.entries, renderer)
+							}]
+						} }
+					}
+				},
+				...attributes
+			],
+			children: []
+		});
+		return rendered;
+	}
 	return async (tree, file) => {
 		const queue = [];
-		async function run(node, props) {
-			let basePath = props.cwd ? file.cwd : generateOptions.basePath;
-			if (file.dirname) basePath ??= file.dirname;
-			const rendered = (await generator.generateTypeTable(props, {
-				...generateOptions,
-				basePath
-			})).map(async (doc) => {
-				return {
-					type: "mdxJsxFlowElement",
-					name: outputName,
-					attributes: [{
-						type: "mdxJsxAttribute",
-						name: "type",
-						value: {
-							type: "mdxJsxAttributeValueExpression",
-							value: remarkStringify ? JSON.stringify(doc, null, 2) : "",
-							data: { estree: {
-								type: "Program",
-								sourceType: "module",
-								body: [{
-									type: "ExpressionStatement",
-									expression: await buildTypeProp(doc.entries, renderer)
-								}]
-							} }
-						}
-					}],
-					children: []
-				};
-			});
-			Object.assign(node, {
-				type: "root",
-				attributes: [],
-				children: await Promise.all(rendered)
-			});
-		}
 		visit(tree, "mdxJsxFlowElement", (node) => {
 			if (node.name !== name) return;
 			const props = {};
+			const attributes = [];
 			const onError = (message, cause) => {
 				const location = node.position ? `${file.path}:${node.position.start.line}:${node.position.start.column}` : file.path;
 				throw new Error(`${location} from <auto-type-table>: ${message}`, { cause });
 			};
-			for (const attr of node.attributes) if (attr.type !== "mdxJsxAttribute") onError("only named attributes are allowed.");
-			else if (typeof attr.value === "string") props[attr.name] = attr.value;
-			else if (attr.value === null) props[attr.name] = true;
-			else onError("only string & boolean attributes are allowed.");
-			queue.push(run(node, props).catch((err) => {
+			for (const attr of node.attributes) {
+				if (attr.type !== "mdxJsxAttribute") {
+					attributes.push(attr);
+					continue;
+				}
+				switch (attr.name) {
+					case "cwd":
+						props.cwd = true;
+						break;
+					case "path":
+					case "name":
+					case "type":
+						if (typeof attr.value === "string") props[attr.name] = attr.value;
+						else onError(`invalid type for attribute ${attr.name}: ${typeof attr.value}, expected: string`);
+						break;
+					default: attributes.push(attr);
+				}
+			}
+			queue.push(generate(file, props, attributes).then((children) => {
+				Object.assign(node, {
+					type: "root",
+					children
+				});
+			}).catch((err) => {
 				onError("failed to generate type table", err);
 			}));
 			return "skip";
@@ -302,13 +326,11 @@ function createFileSystemGeneratorCache(dir) {
 	dir = path.resolve(dir);
 	const initDirPromise = fs.mkdir(dir, { recursive: true }).catch(() => {});
 	return {
-		async write(input, data) {
-			const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+		async write(hash, data) {
 			await initDirPromise;
 			await fs.writeFile(path.join(dir, `${hash}.json`), JSON.stringify(data));
 		},
-		async read(input) {
-			const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+		async read(hash) {
 			try {
 				return JSON.parse((await fs.readFile(path.join(dir, `${hash}.json`))).toString());
 			} catch {
@@ -319,4 +341,4 @@ function createFileSystemGeneratorCache(dir) {
 }
 
 //#endregion
-export { createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };
+export { createFileSystemGeneratorCache, createGenerator, createProject, generateHash, remarkAutoTypeTable };

package/dist/ui/index.d.ts

@@ -1,19 +1,17 @@
-import { i as Generator, l as BaseTypeTableProps, u as GenerateTypeTableOptions } from "../base-Dvhn4vZx.js";
+import { f as BaseTypeTableProps, i as Generator, p as GenerateTypeTableOptions } from "../base-CLqyTLv7.js";
 import * as runtime from "react/jsx-runtime";
 import "server-only";
 import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
-import { ReactNode } from "react";
+import { ComponentProps, ReactNode } from "react";
 
 //#region src/ui/auto-type-table.d.ts
-interface JSXMarkdownRenderer {
-  renderMarkdown: (md: string) => Promise<ReactNode>;
-  renderType: (type: string) => Promise<ReactNode>;
-}
-interface AutoTypeTableProps extends BaseTypeTableProps, Partial<JSXMarkdownRenderer> {
+interface AutoTypeTableProps extends BaseTypeTableProps, ComponentProps<'div'> {
   generator: Generator;
   /** Shiki configuration when using default `renderMarkdown` & `renderType` */
   shiki?: ResolvedShikiConfig;
   options?: GenerateTypeTableOptions;
+  renderMarkdown?: (md: string) => Promise<ReactNode>;
+  renderType?: (type: string) => Promise<ReactNode>;
 }
 declare function AutoTypeTable({
   generator,
@@ -21,6 +19,9 @@ declare function AutoTypeTable({
   renderType,
   renderMarkdown,
   shiki,
+  name,
+  path,
+  type,
   ...props
 }: AutoTypeTableProps): Promise<Promise<runtime.JSX.Element>[]>;
 //#endregion

package/dist/ui/index.js

@@ -1,4 +1,4 @@
-import { n as markdownRenderer, t as parseTags } from "../parse-tags-B09hzgIX.js";
+import { n as markdownRenderer, t as parseTags } from "../parse-tags-D9KSwbHI.js";
 import { TypeTable } from "fumadocs-ui/components/type-table";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import * as runtime from "react/jsx-runtime";
@@ -7,13 +7,17 @@ import defaultMdxComponents from "fumadocs-ui/mdx";
 import "server-only";
 
 //#region src/ui/auto-type-table.tsx
-async function AutoTypeTable({ generator, options = {}, renderType, renderMarkdown, shiki, ...props }) {
+async function AutoTypeTable({ generator, options, renderType, renderMarkdown, shiki, name, path, type, ...props }) {
 	if (!renderType || !renderMarkdown) {
 		const renderer = markdownRenderer(shiki);
 		renderType ??= async (v) => toJsx(await renderer.renderTypeToHast(v));
 		renderMarkdown ??= async (v) => toJsx(await renderer.renderMarkdownToHast(v));
 	}
-	return (await generator.generateTypeTable(props, options)).map(async (item) => {
+	return (await generator.generateTypeTable({
+		name,
+		path,
+		type
+	}, options)).map(async (item) => {
 		const entries = item.entries.map(async (entry) => {
 			const tags = parseTags(entry.tags);
 			const paramNodes = [];
@@ -24,6 +28,7 @@ async function AutoTypeTable({ generator, options = {}, renderType, renderMarkdo
 			return [entry.name, {
 				type: await renderType(entry.simplifiedType),
 				typeDescription: await renderType(entry.type),
+				typeDescriptionLink: entry.typeHref,
 				description: await renderMarkdown(entry.description),
 				default: tags.default ? await renderType(tags.default) : void 0,
 				parameters: paramNodes,
@@ -32,7 +37,11 @@ async function AutoTypeTable({ generator, options = {}, renderType, renderMarkdo
 				returns: tags.returns ? await renderMarkdown(tags.returns) : void 0
 			}];
 		});
-		return /* @__PURE__ */ jsx(TypeTable, { type: Object.fromEntries(await Promise.all(entries)) }, item.name);
+		return /* @__PURE__ */ jsx(TypeTable, {
+			id: `type-table-${item.id}`,
+			type: Object.fromEntries(await Promise.all(entries)),
+			...props
+		}, item.name);
 	});
 }
 function toJsx(hast) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "5.1.1",
+  "version": "5.1.3",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "Docs",
@@ -36,7 +36,6 @@
     "hast-util-to-jsx-runtime": "^2.3.6",
     "remark": "^15.0.1",
     "remark-rehype": "^11.1.2",
-    "tinyglobby": "^0.2.15",
     "ts-morph": "^27.0.2",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0"
@@ -46,17 +45,22 @@
     "@types/estree": "^1.0.8",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
-    "@types/node": "25.1.0",
-    "@types/react": "^19.2.10",
+    "@types/node": "25.2.3",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "tsdown": "^0.19.0",
+    "mdast-util-mdx": "^3.0.0",
+    "tsdown": "^0.20.3",
     "typescript": "^5.9.3",
+    "vfile": "^6.0.3",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "16.5.0",
-    "fumadocs-ui": "16.5.0",
+    "fumadocs-core": "16.6.1",
+    "fumadocs-ui": "16.6.1",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
+    "@types/estree": "*",
+    "@types/hast": "*",
+    "@types/mdast": "*",
     "@types/react": "*",
     "fumadocs-core": "^16.5.0",
     "fumadocs-ui": "^16.5.0",
@@ -64,6 +68,15 @@
     "typescript": "*"
   },
   "peerDependenciesMeta": {
+    "@types/estree": {
+      "optional": true
+    },
+    "@types/hast": {
+      "optional": true
+    },
+    "@types/mdast": {
+      "optional": true
+    },
     "fumadocs-ui": {
       "optional": true
     },