fumadocs-typescript 4.0.6 → 4.0.8

package/dist/{base-CDpZg096.d.ts → base-Q18nCvFH.d.ts}

@@ -56,10 +56,15 @@ interface DocEntry {
     name: string;
     description: string;
     type: string;
-    tags: Record<string, string>;
+    simplifiedType: string;
+    tags: RawTag[];
     required: boolean;
     deprecated: boolean;
 }
+interface RawTag {
+    name: string;
+    text: string;
+}
 interface EntryContext {
     program: Project;
     transform?: Transformer;
@@ -109,4 +114,4 @@ declare function generateDocumentation(file: string, name: string | undefined, c
     project?: Project;
 }): GeneratedDoc[];
 
-export { type BaseTypeTableProps as B, type DocEntry as D, type GenerateOptions as G, type GeneratedDoc as a, type Generator as b, type GenerateTypeTableOptions as c, createProject as d, type GeneratorOptions as e, createGenerator as f, generateDocumentation as g };
+export { type BaseTypeTableProps as B, type DocEntry as D, type GenerateOptions as G, type RawTag as R, type GeneratedDoc as a, type Generator as b, type GenerateTypeTableOptions as c, createProject as d, type GeneratorOptions as e, createGenerator as f, generateDocumentation as g };

package/dist/{chunk-C45FGSN3.js → chunk-HM6PM4II.js}

@@ -57,30 +57,76 @@ import {
   remarkGfm
 } from "fumadocs-core/mdx-plugins";
 import remarkRehype from "remark-rehype";
-var processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, {
+import { highlightHast } from "fumadocs-core/highlight";
+var shikiOptions = {
   lazy: true,
   themes: {
     light: "github-light",
     dark: "github-dark"
   }
-}).use(() => {
-  return (tree, file) => {
-    file.data.tree = tree;
-    return "";
-  };
-});
+};
+var processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, shikiOptions);
+function renderTypeToHast(type) {
+  return __async(this, null, function* () {
+    const nodes = yield highlightHast(type, __spreadProps(__spreadValues({}, shikiOptions), {
+      lang: "ts",
+      structure: "inline"
+    }));
+    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");
-    const out = yield processor.process(md);
-    return out.data.tree;
+    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,
-  renderMarkdownToHast
+  renderTypeToHast,
+  renderMarkdownToHast,
+  parseTags
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { G as GenerateOptions, a as GeneratedDoc, D as DocEntry, b as Generator, c as GenerateTypeTableOptions } from './base-CDpZg096.js';
-export { e as GeneratorOptions, f as createGenerator, d as createProject, g as generateDocumentation } from './base-CDpZg096.js';
+import { G as GenerateOptions, a as GeneratedDoc, D as DocEntry, b as Generator, c as GenerateTypeTableOptions } from './base-Q18nCvFH.js';
+export { e as GeneratorOptions, R as RawTag, f as createGenerator, d as createProject, g as generateDocumentation } from './base-Q18nCvFH.js';
 import { GlobOptions } from 'tinyglobby';
 import { Nodes } from 'hast';
 import { Root } from 'mdast';
@@ -34,6 +34,7 @@ interface GenerateFilesOptions {
 }
 declare function generateFiles(generator: Generator, options: GenerateFilesOptions): Promise<void>;
 
+declare function renderTypeToHast(type: string): Promise<Nodes>;
 declare function renderMarkdownToHast(md: string): Promise<Nodes>;
 
 interface RemarkAutoTypeTableOptions {
@@ -46,6 +47,7 @@ interface RemarkAutoTypeTableOptions {
      */
     outputName?: string;
     renderMarkdown?: typeof renderMarkdownToHast;
+    renderType?: typeof renderTypeToHast;
     /**
      * Customise type table generation
      */
@@ -61,6 +63,6 @@ interface RemarkAutoTypeTableOptions {
  *
  * MDX is required to use this plugin.
  */
-declare function remarkAutoTypeTable({ name, outputName, renderMarkdown, options, remarkStringify, generator, }?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
+declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
 
 export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, Generator, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };

package/dist/index.js

@@ -3,13 +3,15 @@ import {
   __objRest,
   __spreadProps,
   __spreadValues,
-  renderMarkdownToHast
-} from "./chunk-C45FGSN3.js";
+  parseTags,
+  renderMarkdownToHast,
+  renderTypeToHast
+} from "./chunk-HM6PM4II.js";
 
 // src/lib/base.ts
 import {
   Project as Project2,
-  ts
+  ts as ts2
 } from "ts-morph";
 
 // src/create-project.ts
@@ -86,6 +88,54 @@ function createCache() {
 
 // src/lib/base.ts
 import path2 from "path";
+
+// src/lib/get-simple-form.ts
+import * as ts from "ts-morph";
+function getSimpleForm(type, checker, noUndefined = false) {
+  if (type.isUndefined() && noUndefined) return "";
+  const alias = type.getAliasSymbol();
+  if (alias && type.getAliasTypeArguments().length === 0) {
+    return alias.getEscapedName();
+  }
+  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 ? (
+      // boolean | null will become true | false | null, need to ensure it's still returned as boolean
+      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 types.join(" & ");
+  }
+  if (type.isTuple()) {
+    const elements = type.getTupleElements().map((t) => getSimpleForm(t, checker)).join(", ");
+    return `[${elements}]`;
+  }
+  if (type.isArray() || type.isReadonlyArray()) {
+    return "array";
+  }
+  if (type.getCallSignatures().length > 0) {
+    return "function";
+  }
+  if (type.isClassOrInterface() || type.isObject()) {
+    return "object";
+  }
+  return type.getText(
+    void 0,
+    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.InTypeAlias
+  );
+}
+
+// src/lib/base.ts
 function createGenerator(config) {
   var _a;
   const options = config instanceof Project2 ? {
@@ -146,50 +196,62 @@ function generate(program, name, declaration, { allowInternal = false, transform
   );
   return {
     name,
-    description: comment ? ts.displayPartsToString(comment) : "",
+    description: comment ? ts2.displayPartsToString(comment) : "",
     entries: declaration.getType().getProperties().map((prop) => getDocEntry(prop, entryContext)).filter(
       (entry) => entry && (allowInternal || !("internal" in entry.tags))
     )
   };
 }
 function getDocEntry(prop, context) {
-  var _a, _b, _c, _d;
+  var _a, _b;
   const { transform, program } = context;
   if (context.type.isClass() && prop.getName().startsWith("#")) {
     return;
   }
   const subType = program.getTypeChecker().getTypeOfSymbolAtLocation(prop, context.declaration);
-  const tags = Object.fromEntries(
-    prop.getJsDocTags().map((tag) => [tag.getName(), ts.displayPartsToString(tag.getText())])
-  );
-  let typeName = subType.getText(
-    void 0,
-    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+  const isOptional = prop.isOptional();
+  const tags = prop.getJsDocTags().map(
+    (tag) => ({
+      name: tag.getName(),
+      text: ts2.displayPartsToString(tag.getText())
+    })
   );
-  if (subType.getAliasSymbol() && subType.getAliasTypeArguments().length === 0) {
-    typeName = (_b = (_a = subType.getAliasSymbol()) == null ? void 0 : _a.getEscapedName()) != null ? _b : typeName;
-  }
-  if (prop.isOptional() && typeName.endsWith("| undefined")) {
-    typeName = typeName.slice(0, typeName.length - "| undefined".length).trimEnd();
-  }
-  if ("remarks" in tags) {
-    typeName = (_d = (_c = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _c[1]) != null ? _d : typeName;
+  let type = getFullType(subType);
+  for (const tag of tags) {
+    if (tag.name !== "remarks") continue;
+    type = (_b = (_a = new RegExp("^`(?<name>.+)`").exec(tag.text)) == null ? void 0 : _a[1]) != null ? _b : type;
   }
   const entry = {
     name: prop.getName(),
-    description: ts.displayPartsToString(
+    description: ts2.displayPartsToString(
       prop.compilerSymbol.getDocumentationComment(
         program.getTypeChecker().compilerObject
       )
     ),
     tags,
-    type: typeName,
-    required: !prop.isOptional(),
-    deprecated: prop.getJsDocTags().some((tag) => tag.getName() === "deprecated")
+    type,
+    simplifiedType: getSimpleForm(
+      subType,
+      program.getTypeChecker(),
+      isOptional
+    ),
+    required: !isOptional,
+    deprecated: tags.some((tag) => tag.name === "deprecated")
   };
   transform == null ? void 0 : transform.call(context, entry, subType, prop);
   return entry;
 }
+function getFullType(type) {
+  var _a, _b;
+  let typeName = type.getText(
+    void 0,
+    ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts2.TypeFormatFlags.NoTruncation | ts2.TypeFormatFlags.InTypeAlias
+  );
+  if (type.getAliasSymbol() && type.getAliasTypeArguments().length === 0) {
+    typeName = (_b = (_a = type.getAliasSymbol()) == null ? void 0 : _a.getEscapedName()) != null ? _b : typeName;
+  }
+  return typeName;
+}
 
 // src/lib/mdx.ts
 import * as path3 from "path";
@@ -209,8 +271,8 @@ ${doc.description}
 
 ${c.description || "No Description"}
 
-${Object.entries(c.tags).map(([tag, value]) => `- ${tag}:
-${replaceJsDocLinks(value)}`).join("\n")}
+${c.tags.map((tag) => `- ${tag.name}:
+${replaceJsDocLinks(tag.text)}`).join("\n")}
 
 </div>`
 };
@@ -267,61 +329,111 @@ function write(file, content) {
   });
 }
 
-// src/lib/remark-auto-type-table.tsx
+// src/lib/remark-auto-type-table.ts
 import { valueToEstree } from "estree-util-value-to-estree";
 import { visit } from "unist-util-visit";
 import { toEstree } from "hast-util-to-estree";
 import { dirname as dirname2 } from "path";
-function mapProperty(entry, renderMarkdown) {
-  return __async(this, null, function* () {
-    const value = valueToEstree({
-      type: entry.type,
-      default: entry.tags.default || entry.tags.defaultValue,
-      required: entry.required
-    });
-    if (entry.description) {
-      const hast = toEstree(yield renderMarkdown(entry.description), {
-        elementAttributeNameCase: "react"
-      }).body[0];
-      value.properties.push({
+function objectBuilder() {
+  const out = {
+    type: "ObjectExpression",
+    properties: []
+  };
+  return {
+    addExpressionNode(key, expression) {
+      out.properties.push({
         type: "Property",
         method: false,
         shorthand: false,
         computed: false,
         key: {
           type: "Identifier",
-          name: "description"
+          name: key
         },
         kind: "init",
-        value: hast.expression
+        value: expression
       });
+    },
+    addJsxProperty(key, hast) {
+      const estree = toEstree(hast, {
+        elementAttributeNameCase: "react"
+      }).body[0];
+      this.addExpressionNode(key, estree.expression);
+    },
+    build() {
+      return out;
+    }
+  };
+}
+function buildTypeProp(_0, _1) {
+  return __async(this, arguments, function* (entries, {
+    renderMarkdown = renderMarkdownToHast,
+    renderType = renderTypeToHast
+  }) {
+    function onItem(entry) {
+      return __async(this, null, function* () {
+        const node = objectBuilder();
+        node.addJsxProperty("type", yield renderType(entry.simplifiedType));
+        node.addJsxProperty("typeDescription", yield renderType(entry.type));
+        node.addExpressionNode("required", valueToEstree(entry.required));
+        const tags = parseTags(entry.tags);
+        if (tags.default)
+          node.addJsxProperty("default", yield renderType(tags.default));
+        if (tags.returns)
+          node.addJsxProperty("returns", yield renderMarkdown(tags.returns));
+        if (tags.params) {
+          node.addExpressionNode("parameters", {
+            type: "ArrayExpression",
+            elements: yield Promise.all(tags.params.map(onParam))
+          });
+        }
+        if (entry.description) {
+          node.addJsxProperty(
+            "description",
+            yield renderMarkdown(entry.description)
+          );
+        }
+        return node.build();
+      });
+    }
+    function onParam(param) {
+      return __async(this, null, function* () {
+        const node = objectBuilder();
+        node.addExpressionNode("name", valueToEstree(param.name));
+        if (param.description)
+          node.addJsxProperty(
+            "description",
+            yield renderMarkdown(param.description)
+          );
+        return node.build();
+      });
+    }
+    const prop = objectBuilder();
+    const output = yield Promise.all(
+      entries.map((entry) => __async(null, null, function* () {
+        return {
+          name: entry.name,
+          node: yield onItem(entry)
+        };
+      }))
+    );
+    for (const node of output) {
+      prop.addExpressionNode(node.name, node.node);
     }
-    return {
-      type: "Property",
-      method: false,
-      shorthand: false,
-      computed: false,
-      key: {
-        type: "Literal",
-        value: entry.name
-      },
-      kind: "init",
-      value
-    };
+    return prop.build();
   });
 }
-function remarkAutoTypeTable({
-  name = "auto-type-table",
-  outputName = "TypeTable",
-  renderMarkdown = renderMarkdownToHast,
-  options = {},
-  remarkStringify = true,
-  generator = createGenerator()
-} = {}) {
+function remarkAutoTypeTable(config = {}) {
+  const {
+    name = "auto-type-table",
+    outputName = "TypeTable",
+    options: generateOptions = {},
+    remarkStringify = true,
+    generator = createGenerator()
+  } = config;
   return (tree, file) => __async(null, null, function* () {
     const queue = [];
-    let basePath = options == null ? void 0 : options.basePath;
-    if (!basePath && file.path) basePath = dirname2(file.path);
+    const defaultBasePath = file.path ? dirname2(file.path) : void 0;
     visit(tree, "mdxJsxFlowElement", (node) => {
       if (node.name !== name) return;
       const props = {};
@@ -334,16 +446,14 @@ function remarkAutoTypeTable({
       }
       function run() {
         return __async(this, null, function* () {
+          var _a;
           const output = yield generator.generateTypeTable(
             props,
-            __spreadProps(__spreadValues({}, options), {
-              basePath
+            __spreadProps(__spreadValues({}, generateOptions), {
+              basePath: (_a = generateOptions.basePath) != null ? _a : defaultBasePath
             })
           );
           const rendered = output.map((doc) => __async(null, null, function* () {
-            const properties = yield Promise.all(
-              doc.entries.map((entry) => mapProperty(entry, renderMarkdown))
-            );
             return {
               type: "mdxJsxFlowElement",
               name: outputName,
@@ -361,10 +471,7 @@ function remarkAutoTypeTable({
                         body: [
                           {
                             type: "ExpressionStatement",
-                            expression: {
-                              type: "ObjectExpression",
-                              properties
-                            }
+                            expression: yield buildTypeProp(doc.entries, config)
                           }
                         ]
                       }

package/dist/ui/index.d.ts

@@ -1,14 +1,16 @@
 import * as runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { B as BaseTypeTableProps, b as Generator, c as GenerateTypeTableOptions } from '../base-CDpZg096.js';
+import { B as BaseTypeTableProps, b as Generator, c as GenerateTypeTableOptions } from '../base-Q18nCvFH.js';
 import 'ts-morph';
 
 type AutoTypeTableProps = BaseTypeTableProps;
-declare function AutoTypeTable({ generator, options, renderMarkdown, ...props }: AutoTypeTableProps & {
+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 };

package/dist/ui/index.js

@@ -3,11 +3,15 @@ import {
   __objRest,
   __spreadProps,
   __spreadValues,
-  renderMarkdownToHast
-} from "../chunk-C45FGSN3.js";
+  parseTags,
+  renderMarkdownToHast,
+  renderTypeToHast
+} from "../chunk-HM6PM4II.js";
 
 // src/ui/auto-type-table.tsx
-import { TypeTable } from "fumadocs-ui/components/type-table";
+import {
+  TypeTable
+} from "fumadocs-ui/components/type-table";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import * as runtime from "react/jsx-runtime";
 import defaultMdxComponents from "fumadocs-ui/mdx";
@@ -18,28 +22,40 @@ function AutoTypeTable(_a) {
     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* () {
-          return [
-            entry.name,
-            {
-              type: entry.type,
-              description: yield renderMarkdown(entry.description),
-              default: entry.tags.default || entry.tags.defaultValue,
-              required: entry.required,
-              deprecated: entry.deprecated
-            }
-          ];
-        })
-      );
+      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,
         {
@@ -50,14 +66,22 @@ function AutoTypeTable(_a) {
     }));
   });
 }
+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));
+  });
+}
 function renderMarkdownDefault(md) {
   return __async(this, null, function* () {
-    return toJsxRuntime(yield renderMarkdownToHast(md), {
-      Fragment: runtime.Fragment,
-      jsx: runtime.jsx,
-      jsxs: runtime.jsxs,
-      components: __spreadProps(__spreadValues({}, defaultMdxComponents), { img: void 0 })
-    });
+    return toJsx(yield renderMarkdownToHast(md));
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "4.0.6",
+  "version": "4.0.8",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "NextJs",
@@ -33,31 +33,35 @@
     "hast-util-to-jsx-runtime": "^2.3.6",
     "remark": "^15.0.1",
     "remark-rehype": "^11.1.2",
-    "shiki": "^3.6.0",
     "tinyglobby": "^0.2.14",
     "ts-morph": "^26.0.0",
     "unist-util-visit": "^5.0.0"
   },
   "devDependencies": {
-    "@mdx-js/mdx": "^3.1.0",
+    "@mdx-js/mdx": "^3.1.1",
     "@types/estree": "^1.0.8",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.3",
-    "@types/node": "24.0.1",
-    "@types/react": "19.1.8",
-    "@types/react-dom": "19.1.6",
-    "typescript": "^5.8.3",
+    "@types/node": "24.3.1",
+    "@types/react": "19.1.12",
+    "@types/react-dom": "19.1.9",
+    "typescript": "^5.9.2",
     "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "15.5.2",
-    "fumadocs-ui": "15.5.2",
+    "fumadocs-core": "15.7.10",
+    "fumadocs-ui": "15.7.10",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "typescript": "*",
-    "@types/react": "*"
+    "@types/react": "*",
+    "fumadocs-core": "^15.7.0",
+    "fumadocs-ui": "^15.7.0",
+    "typescript": "*"
   },
   "peerDependenciesMeta": {
+    "fumadocs-ui": {
+      "optional": true
+    },
     "@types/react": {
       "optional": true
     }