fumadocs-typescript 5.0.0 → 5.1.0

package/dist/parse-tags-B09hzgIX.js

@@ -0,0 +1,68 @@
+import { remark } from "remark";
+import { remarkGfm } from "fumadocs-core/mdx-plugins/remark-gfm";
+import { createRehypeCode } from "fumadocs-core/mdx-plugins/rehype-code.core";
+import remarkRehype from "remark-rehype";
+import { highlightHast } from "fumadocs-core/highlight/core";
+import { configDefault } from "fumadocs-core/highlight";
+
+//#region src/markdown.ts
+function markdownRenderer(shiki = configDefault) {
+	const processor = remark().use(remarkGfm).use(remarkRehype).use(createRehypeCode(shiki), {
+		lazy: true,
+		langs: ["ts", "tsx"],
+		transformers: [],
+		parseMetaString: void 0
+	});
+	return {
+		async renderTypeToHast(type) {
+			return {
+				type: "element",
+				tagName: "span",
+				properties: { class: "shiki" },
+				children: [{
+					type: "element",
+					tagName: "code",
+					properties: {},
+					children: (await highlightHast(type, {
+						config: shiki,
+						lang: "ts",
+						structure: "inline"
+					})).children
+				}]
+			};
+		},
+		renderMarkdownToHast(md) {
+			md = md.replace(/{@link (?<link>[^}]*)}/g, "$1");
+			return processor.run(processor.parse(md));
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/parse-tags.ts
+/**
+* Parse tags, only returns recognized fields.
+*/
+function parseTags(tags) {
+	const typed = {};
+	for (const { name: key, text } of tags) {
+		if (key === "default" || key === "defaultValue") {
+			typed.default = text;
+			continue;
+		}
+		if (key === "param") {
+			const [param, description] = text.split("-", 2);
+			typed.params ??= [];
+			typed.params.push({
+				name: param.trim(),
+				description: description.trim()
+			});
+			continue;
+		}
+		if (key === "returns") typed.returns = text;
+	}
+	return typed;
+}
+
+//#endregion
+export { markdownRenderer as n, parseTags as t };

package/dist/ui/index.d.ts

@@ -1,16 +1,27 @@
-import * as runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-import { B as BaseTypeTableProps, a as Generator, G as GenerateTypeTableOptions } from '../base-C72MF-7Q.js';
-import 'ts-morph';
+import { i as Generator, l as BaseTypeTableProps, u as GenerateTypeTableOptions } from "../base-Dvhn4vZx.js";
+import * as runtime from "react/jsx-runtime";
+import "server-only";
+import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
+import { ReactNode } from "react";
 
-type AutoTypeTableProps = BaseTypeTableProps;
-declare function AutoTypeTable({ generator, options, renderType, renderMarkdown, ...props }: AutoTypeTableProps & {
-    generator: Generator;
-    renderMarkdown?: typeof renderMarkdownDefault;
-    renderType?: typeof renderTypeDefault;
-    options?: GenerateTypeTableOptions;
-}): Promise<Promise<runtime.JSX.Element>[]>;
-declare function renderTypeDefault(type: string): Promise<ReactNode>;
-declare function renderMarkdownDefault(md: string): Promise<ReactNode>;
-
-export { AutoTypeTable, type AutoTypeTableProps };
+//#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> {
+  generator: Generator;
+  /** Shiki configuration when using default `renderMarkdown` & `renderType` */
+  shiki?: ResolvedShikiConfig;
+  options?: GenerateTypeTableOptions;
+}
+declare function AutoTypeTable({
+  generator,
+  options,
+  renderType,
+  renderMarkdown,
+  shiki,
+  ...props
+}: AutoTypeTableProps): Promise<Promise<runtime.JSX.Element>[]>;
+//#endregion
+export { AutoTypeTable, AutoTypeTableProps };

package/dist/ui/index.js

@@ -1,89 +1,51 @@
-import {
-  __async,
-  __objRest,
-  __spreadProps,
-  __spreadValues,
-  parseTags,
-  renderMarkdownToHast,
-  renderTypeToHast
-} from "../chunk-H4DZJVYN.js";
-
-// src/ui/auto-type-table.tsx
-import {
-  TypeTable
-} from "fumadocs-ui/components/type-table";
+import { n as markdownRenderer, t as parseTags } from "../parse-tags-B09hzgIX.js";
+import { TypeTable } from "fumadocs-ui/components/type-table";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import * as runtime from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import defaultMdxComponents from "fumadocs-ui/mdx";
 import "server-only";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function AutoTypeTable(_a) {
-  return __async(this, null, function* () {
-    var _b = _a, {
-      generator,
-      options = {},
-      renderType = renderTypeDefault,
-      renderMarkdown = renderMarkdownDefault
-    } = _b, props = __objRest(_b, [
-      "generator",
-      "options",
-      "renderType",
-      "renderMarkdown"
-    ]);
-    const output = yield generator.generateTypeTable(props, options);
-    return output.map((item) => __async(null, null, function* () {
-      const entries = item.entries.map((entry) => __async(null, null, function* () {
-        var _a2;
-        const tags = parseTags(entry.tags);
-        const paramNodes = [];
-        for (const param of (_a2 = tags.params) != null ? _a2 : []) {
-          paramNodes.push({
-            name: param.name,
-            description: param.description ? yield renderMarkdown(param.description) : void 0
-          });
-        }
-        return [
-          entry.name,
-          {
-            type: yield renderType(entry.simplifiedType),
-            typeDescription: yield renderType(entry.type),
-            description: yield renderMarkdown(entry.description),
-            default: tags.default ? yield renderType(tags.default) : void 0,
-            parameters: paramNodes,
-            required: entry.required,
-            deprecated: entry.deprecated,
-            returns: tags.returns ? yield renderMarkdown(tags.returns) : void 0
-          }
-        ];
-      }));
-      return /* @__PURE__ */ jsx2(
-        TypeTable,
-        {
-          type: Object.fromEntries(yield Promise.all(entries))
-        },
-        item.name
-      );
-    }));
-  });
+
+//#region src/ui/auto-type-table.tsx
+async function AutoTypeTable({ generator, options = {}, renderType, renderMarkdown, shiki, ...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) => {
+		const entries = item.entries.map(async (entry) => {
+			const tags = parseTags(entry.tags);
+			const paramNodes = [];
+			for (const param of tags.params ?? []) paramNodes.push({
+				name: param.name,
+				description: param.description ? await renderMarkdown(param.description) : void 0
+			});
+			return [entry.name, {
+				type: await renderType(entry.simplifiedType),
+				typeDescription: await renderType(entry.type),
+				description: await renderMarkdown(entry.description),
+				default: tags.default ? await renderType(tags.default) : void 0,
+				parameters: paramNodes,
+				required: entry.required,
+				deprecated: entry.deprecated,
+				returns: tags.returns ? await renderMarkdown(tags.returns) : void 0
+			}];
+		});
+		return /* @__PURE__ */ jsx(TypeTable, { type: Object.fromEntries(await Promise.all(entries)) }, item.name);
+	});
 }
 function toJsx(hast) {
-  return toJsxRuntime(hast, {
-    Fragment: runtime.Fragment,
-    jsx: runtime.jsx,
-    jsxs: runtime.jsxs,
-    components: __spreadProps(__spreadValues({}, defaultMdxComponents), { img: void 0 })
-  });
-}
-function renderTypeDefault(type) {
-  return __async(this, null, function* () {
-    return toJsx(yield renderTypeToHast(type));
-  });
+	return toJsxRuntime(hast, {
+		Fragment: runtime.Fragment,
+		jsx: runtime.jsx,
+		jsxs: runtime.jsxs,
+		components: {
+			...defaultMdxComponents,
+			img: void 0
+		}
+	});
 }
-function renderMarkdownDefault(md) {
-  return __async(this, null, function* () {
-    return toJsx(yield renderMarkdownToHast(md));
-  });
-}
-export {
-  AutoTypeTable
-};
+
+//#endregion
+export { AutoTypeTable };

package/package.json

@@ -1,32 +1,35 @@
 {
   "name": "fumadocs-typescript",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
+    "Docs",
     "NextJs",
-    "fumadocs",
-    "Docs"
+    "fumadocs"
   ],
   "homepage": "https://fumadocs.dev",
-  "repository": "github:fuma-nama/fumadocs",
   "license": "MIT",
   "author": "Fuma Nama",
+  "repository": "github:fuma-nama/fumadocs",
+  "files": [
+    "dist/*"
+  ],
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./ui": {
-      "import": "./dist/ui/index.js",
-      "types": "./dist/ui/index.d.ts"
+      "types": "./dist/ui/index.d.ts",
+      "import": "./dist/ui/index.js"
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/*"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "estree-util-value-to-estree": "^3.5.0",
     "hast-util-to-estree": "^3.1.3",
@@ -35,27 +38,29 @@
     "remark-rehype": "^11.1.2",
     "tinyglobby": "^0.2.15",
     "ts-morph": "^27.0.2",
-    "unist-util-visit": "^5.0.0"
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0"
   },
   "devDependencies": {
     "@mdx-js/mdx": "^3.1.1",
     "@types/estree": "^1.0.8",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
-    "@types/node": "24.10.2",
-    "@types/react": "^19.2.7",
+    "@types/node": "25.1.0",
+    "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
+    "tsdown": "^0.19.0",
     "typescript": "^5.9.3",
-    "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "16.3.2",
-    "fumadocs-ui": "16.3.2",
+    "fumadocs-core": "17.0.0",
+    "fumadocs-ui": "17.0.0",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "@types/react": "*",
-    "fumadocs-core": "^15.7.0 || ^16.0.0",
-    "fumadocs-ui": "^15.7.0 || ^16.0.0",
+    "fumadocs-core": "^16.5.0",
+    "fumadocs-ui": "^16.5.0",
+    "react": "*",
     "typescript": "*"
   },
   "peerDependenciesMeta": {
@@ -66,13 +71,10 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "clean": "rimraf dist",
-    "dev": "tsup --watch",
+    "dev": "tsdown --watch",
     "lint": "eslint .",
     "types:check": "tsc --noEmit"
   }

package/dist/base-C72MF-7Q.d.ts

@@ -1,110 +0,0 @@
-import { Project, Type, ExportedDeclarations, Symbol } from 'ts-morph';
-
-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;
-
-interface BaseTypeTableProps {
-    /**
-     * The path to source TypeScript file.
-     */
-    path?: string;
-    /**
-     * Exported type name to generate from.
-     */
-    name?: string;
-    /**
-     * Set the type to generate from.
-     *
-     * When used with `name`, it generates the type with `name` as export name.
-     *
-     * ```ts
-     * export const myName = MyType;
-     * ```
-     *
-     * When `type` contains multiple lines, `export const` is not added.
-     * You need to export it manually, and specify the type name with `name`.
-     *
-     * ```tsx
-     * <AutoTypeTable
-     *   path="./file.ts"
-     *   type={`import { ReactNode } from "react"
-     *   export const MyName = ReactNode`}
-     *   name="MyName"
-     * />
-     * ```
-     */
-    type?: string;
-}
-interface GenerateTypeTableOptions extends GenerateOptions {
-    /**
-     * base path to resolve `path` prop
-     */
-    basePath?: string;
-}
-
-interface Cache {
-    read: (key: string) => unknown | undefined | Promise<unknown | undefined>;
-    write: (key: string, value: unknown) => void | Promise<void>;
-}
-
-interface GeneratedDoc {
-    name: string;
-    description: string;
-    entries: DocEntry[];
-}
-interface DocEntry {
-    name: string;
-    description: string;
-    type: string;
-    simplifiedType: string;
-    tags: RawTag[];
-    required: boolean;
-    deprecated: boolean;
-}
-interface RawTag {
-    name: string;
-    text: string;
-}
-interface EntryContext {
-    program: Project;
-    transform?: Transformer;
-    type: Type;
-    declaration: ExportedDeclarations;
-}
-type Transformer = (this: EntryContext, entry: DocEntry, propertyType: Type, propertySymbol: Symbol) => void;
-interface GenerateOptions {
-    /**
-     * Allow fields with `@internal` tag
-     *
-     * @defaultValue false
-     */
-    allowInternal?: boolean;
-    /**
-     * Modify output property entry
-     */
-    transform?: Transformer;
-}
-type Generator = ReturnType<typeof createGenerator>;
-interface GeneratorOptions extends TypescriptConfig {
-    /**
-     * cache results, note that some options are not marked as dependency.
-     *
-     * @defaultValue false
-     */
-    cache?: Cache | false;
-    project?: Project;
-}
-declare function createGenerator(config?: GeneratorOptions | Project): {
-    generateDocumentation(file: {
-        path: string;
-        content?: string;
-    }, name: string | undefined, options?: GenerateOptions): Promise<GeneratedDoc[]>;
-    generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions): Promise<GeneratedDoc[]>;
-};
-
-export { type BaseTypeTableProps as B, type Cache as C, type DocEntry as D, type GenerateTypeTableOptions as G, type RawTag as R, type Generator as a, type GeneratedDoc as b, createProject as c, type GenerateOptions as d, type GeneratorOptions as e, createGenerator as f };

package/dist/chunk-H4DZJVYN.js

@@ -1,142 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/markdown.ts
-import { remark } from "remark";
-import { remarkGfm } from "fumadocs-core/mdx-plugins/remark-gfm";
-import {
-  rehypeCode
-} from "fumadocs-core/mdx-plugins/rehype-code";
-import remarkRehype from "remark-rehype";
-import { getHighlighter } from "fumadocs-core/highlight";
-var shikiOptions = {
-  lazy: true,
-  langs: ["ts", "tsx"],
-  // disable default transformers & meta parser
-  transformers: [],
-  parseMetaString: void 0,
-  themes: {
-    light: "github-light",
-    dark: "github-dark"
-  }
-};
-var processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, shikiOptions);
-function renderTypeToHast(type) {
-  return __async(this, null, function* () {
-    const highlighter = yield getHighlighter("js", {
-      langs: ["ts"],
-      themes: Object.values(shikiOptions.themes)
-    });
-    const nodes = highlighter.codeToHast(type, {
-      lang: "ts",
-      structure: "inline",
-      themes: shikiOptions.themes,
-      defaultColor: false
-    });
-    return {
-      type: "element",
-      tagName: "span",
-      properties: {
-        class: "shiki"
-      },
-      children: [
-        {
-          type: "element",
-          tagName: "code",
-          properties: {},
-          children: nodes.children
-        }
-      ]
-    };
-  });
-}
-function renderMarkdownToHast(md) {
-  return __async(this, null, function* () {
-    md = md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
-    return processor.run(processor.parse(md));
-  });
-}
-
-// src/lib/parse-tags.ts
-function parseTags(tags) {
-  var _a;
-  const typed = {};
-  for (const { name: key, text } of tags) {
-    if (key === "default" || key === "defaultValue") {
-      typed.default = text;
-      continue;
-    }
-    if (key === "param") {
-      const [param, description] = text.split("-", 2);
-      (_a = typed.params) != null ? _a : typed.params = [];
-      typed.params.push({
-        name: param.trim(),
-        description: description.trim()
-      });
-      continue;
-    }
-    if (key === "returns") {
-      typed.returns = text;
-    }
-  }
-  return typed;
-}
-
-export {
-  __spreadValues,
-  __spreadProps,
-  __objRest,
-  __async,
-  renderTypeToHast,
-  renderMarkdownToHast,
-  parseTags
-};