fumadocs-typescript 3.0.3 → 3.1.0

package/dist/{chunk-2L4CMRDQ.js → chunk-LRCT2FYJ.js}

@@ -60,7 +60,7 @@ function getProject(options = {}) {
   });
 }
 
-// src/generate/base.ts
+// src/lib/base.ts
 import {
   ts
 } from "ts-morph";
@@ -125,71 +125,77 @@ function getDocEntry(prop, context) {
       )
     ),
     tags,
-    type: typeName
+    type: typeName,
+    required: !prop.isOptional()
   };
   transform == null ? void 0 : transform.call(context, entry, subType, prop);
   return entry;
 }
 
 // src/markdown.ts
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { gfmFromMarkdown } from "mdast-util-gfm";
-import { toHast } from "mdast-util-to-hast";
-import { getSingletonHighlighter } from "shiki";
+import { remark } from "remark";
+import {
+  remarkGfm,
+  rehypeCode
+} from "fumadocs-core/mdx-plugins";
+import remarkRehype from "remark-rehype";
+var processor = remark().use(remarkGfm).use(remarkRehype).use(rehypeCode, {
+  lazy: true,
+  themes: {
+    light: "github-light",
+    dark: "github-dark"
+  }
+}).use(() => {
+  return (tree, file) => {
+    file.data.tree = tree;
+    return "";
+  };
+});
 function renderMarkdownToHast(md) {
   return __async(this, null, function* () {
-    const mdast = fromMarkdown(
-      md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1"),
-      // replace jsdoc links
-      { mdastExtensions: [gfmFromMarkdown()] }
-    );
-    const highlighter = yield getSingletonHighlighter({
-      themes: ["vitesse-light", "vitesse-dark"]
-    });
-    function preload(contents) {
-      return __async(this, null, function* () {
-        yield Promise.all(
-          contents.map((c) => __async(this, null, function* () {
-            if ("children" in c) yield preload(c.children);
-            if (c.type === "code" && c.lang) {
-              yield highlighter.loadLanguage(
-                c.lang
-              );
-            }
-          }))
-        );
-      });
+    md = md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
+    const out = yield processor.process(md);
+    return out.data.tree;
+  });
+}
+
+// src/utils/type-table.ts
+import * as fs from "node:fs/promises";
+import { join } from "node:path";
+function getTypeTableOutput(_a) {
+  return __async(this, null, function* () {
+    var _b = _a, {
+      name,
+      type,
+      options
+    } = _b, props = __objRest(_b, [
+      "name",
+      "type",
+      "options"
+    ]);
+    const file = props.path && (options == null ? void 0 : options.basePath) ? join(options.basePath, props.path) : props.path;
+    let typeName = name;
+    let content = "";
+    if (file) {
+      content = (yield fs.readFile(file)).toString();
     }
-    yield preload(mdast.children);
-    return toHast(mdast, {
-      handlers: {
-        // @ts-expect-error hast with mdx
-        code(_, node) {
-          var _a;
-          const lang = (_a = node.lang) != null ? _a : "plaintext";
-          return highlighter.codeToHast(node.value, {
-            lang,
-            themes: {
-              light: "vitesse-light",
-              dark: "vitesse-dark"
-            },
-            defaultColor: false,
-            transformers: [
-              {
-                name: "rehype-code:pre-process",
-                line(hast) {
-                  if (hast.children.length > 0) return;
-                  hast.children.push({
-                    type: "text",
-                    value: " "
-                  });
-                }
-              }
-            ]
-          }).children;
-        }
-      }
-    });
+    if (type && type.split("\n").length > 1) {
+      content += `
+${type}`;
+    } else if (type) {
+      typeName != null ? typeName : typeName = "$Fumadocs";
+      content += `
+export type ${typeName} = ${type}`;
+    }
+    const output = generateDocumentation(
+      file != null ? file : "temp.ts",
+      typeName,
+      content,
+      options
+    );
+    if (name && output.length === 0)
+      throw new Error(`${name} in ${file != null ? file : "empty file"} doesn't exist`);
+    return output;
   });
 }
 
@@ -201,5 +207,6 @@ export {
   getProject,
   generateDocumentation,
   generate,
-  renderMarkdownToHast
+  renderMarkdownToHast,
+  getTypeTableOutput
 };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { G as GenerateDocumentationOptions, a as GeneratedDoc, D as DocEntry } from './base-BltLCalB.js';
-export { b as GenerateOptions, d as generate, c as generateDocumentation, g as getProject } from './base-BltLCalB.js';
+import { G as GenerateDocumentationOptions, a as GeneratedDoc, D as DocEntry, B as BaseTypeTableProps } from './type-table-DyymKQK8.js';
+export { b as GenerateOptions, d as generate, c as generateDocumentation, g as getProject } from './type-table-DyymKQK8.js';
 import fg from 'fast-glob';
 import { Nodes } from 'hast';
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
 import 'ts-morph';
 
 interface Templates {
@@ -34,4 +36,26 @@ declare function generateFiles(options: GenerateFilesOptions): Promise<void>;
 
 declare function renderMarkdownToHast(md: string): Promise<Nodes>;
 
-export { DocEntry, GenerateDocumentationOptions, type GenerateFilesOptions, type GenerateMDXOptions, GeneratedDoc, generateFiles, generateMDX, renderMarkdownToHast };
+interface RemarkAutoTypeTableOptions {
+    /**
+     * @defaultValue 'auto-type-table'
+     */
+    name?: string;
+    /**
+     * @defaultValue 'TypeTable'
+     */
+    outputName?: string;
+    renderMarkdown?: typeof renderMarkdownToHast;
+    /**
+     * Override some type table props
+     */
+    options?: BaseTypeTableProps['options'];
+}
+/**
+ * Compile `auto-type-table` into Fumadocs UI compatible TypeTable
+ *
+ * MDX is required to use this plugin.
+ */
+declare function remarkAutoTypeTable({ name, outputName, renderMarkdown, options, }?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
+
+export { DocEntry, GenerateDocumentationOptions, type GenerateFilesOptions, type GenerateMDXOptions, GeneratedDoc, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };

package/dist/index.js

@@ -6,10 +6,11 @@ import {
   generate,
   generateDocumentation,
   getProject,
+  getTypeTableOutput,
   renderMarkdownToHast
-} from "./chunk-2L4CMRDQ.js";
+} from "./chunk-LRCT2FYJ.js";
 
-// src/generate/mdx.ts
+// src/lib/mdx.ts
 import * as path from "node:path";
 import fs from "node:fs";
 var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
@@ -54,7 +55,7 @@ function replaceJsDocLinks(md) {
   return md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
 }
 
-// src/generate/file.ts
+// src/lib/file.ts
 import * as path2 from "node:path";
 import { mkdir, writeFile, readFile } from "node:fs/promises";
 import fg from "fast-glob";
@@ -90,11 +91,145 @@ function write(file, content) {
     yield writeFile(file, content);
   });
 }
+
+// src/lib/remark-auto-type-table.tsx
+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 "node:path";
+function expressionToAttribute(key, value) {
+  return {
+    type: "mdxJsxAttribute",
+    name: key,
+    value: {
+      type: "mdxJsxAttributeValueExpression",
+      data: {
+        estree: {
+          type: "Program",
+          body: [
+            {
+              type: "ExpressionStatement",
+              expression: value
+            }
+          ]
+        }
+      }
+    }
+  };
+}
+function mapProperty(entry, renderMarkdown) {
+  return __async(this, null, function* () {
+    const value = valueToEstree({
+      type: entry.type,
+      default: entry.tags.default || entry.tags.defaultValue
+    });
+    if (entry.description) {
+      const hast = toEstree(yield renderMarkdown(entry.description), {
+        elementAttributeNameCase: "react"
+      }).body[0];
+      value.properties.push({
+        type: "Property",
+        method: false,
+        shorthand: false,
+        computed: false,
+        key: {
+          type: "Identifier",
+          name: "description"
+        },
+        kind: "init",
+        value: hast.expression
+      });
+    }
+    return {
+      type: "Property",
+      method: false,
+      shorthand: false,
+      computed: false,
+      key: {
+        type: "Identifier",
+        name: entry.name
+      },
+      kind: "init",
+      value
+    };
+  });
+}
+function remarkAutoTypeTable({
+  name = "auto-type-table",
+  outputName = "TypeTable",
+  renderMarkdown = renderMarkdownToHast,
+  options = {}
+} = {}) {
+  var _a;
+  const project = (_a = options.project) != null ? _a : getProject(options.config);
+  return (tree, file) => __async(this, null, function* () {
+    const queue = [];
+    let basePath = options == null ? void 0 : options.basePath;
+    if (!basePath && file.path) basePath = dirname2(file.path);
+    visit(tree, "mdxJsxFlowElement", (node) => {
+      if (node.name !== name) return;
+      const props = {};
+      for (const attr of node.attributes) {
+        if (attr.type !== "mdxJsxAttribute" || typeof attr.value !== "string")
+          throw new Error(
+            "`auto-type-table` does not support non-string attributes"
+          );
+        props[attr.name] = attr.value;
+      }
+      function run() {
+        return __async(this, null, function* () {
+          const output = yield getTypeTableOutput(__spreadProps(__spreadValues({}, props), {
+            options: __spreadProps(__spreadValues({}, options), {
+              project,
+              basePath
+            })
+          }));
+          const rendered = output.map((doc) => __async(this, null, function* () {
+            const properties = yield Promise.all(
+              doc.entries.map((entry) => mapProperty(entry, renderMarkdown))
+            );
+            return {
+              type: "mdxJsxFlowElement",
+              name: outputName,
+              attributes: [
+                expressionToAttribute("type", {
+                  type: "ObjectExpression",
+                  properties
+                })
+              ],
+              data: {
+                // for Fumadocs `remarkStructure`
+                _string: [
+                  doc.name,
+                  doc.description,
+                  ...doc.entries.flatMap((entry) => [
+                    `${entry.name}: ${entry.type}`,
+                    entry.description
+                  ])
+                ]
+              },
+              children: []
+            };
+          }));
+          Object.assign(node, {
+            type: "root",
+            attributes: [],
+            children: yield Promise.all(rendered)
+          });
+        });
+      }
+      queue.push(run());
+      return "skip";
+    });
+    yield Promise.all(queue);
+  });
+}
 export {
   generate,
   generateDocumentation,
   generateFiles,
   generateMDX,
   getProject,
+  remarkAutoTypeTable,
   renderMarkdownToHast
 };

package/dist/{base-BltLCalB.d.ts → type-table-DyymKQK8.d.ts}

@@ -1,4 +1,4 @@
-import { Project, ExportedDeclarations, Type, Symbol } from 'ts-morph';
+import { Project, Type, ExportedDeclarations, Symbol } from 'ts-morph';
 
 interface TypescriptConfig {
     files?: string[];
@@ -18,6 +18,7 @@ interface DocEntry {
     description: string;
     type: string;
     tags: Record<string, string>;
+    required: boolean;
 }
 interface EntryContext {
     program: Project;
@@ -51,4 +52,43 @@ interface GenerateDocumentationOptions extends GenerateOptions {
 declare function generateDocumentation(file: string, name: string | undefined, content: string, options?: GenerateDocumentationOptions): GeneratedDoc[];
 declare function generate(program: Project, name: string, declaration: ExportedDeclarations, { allowInternal, transform }: GenerateOptions): GeneratedDoc;
 
-export { type DocEntry as D, type GenerateDocumentationOptions as G, type GeneratedDoc as a, type GenerateOptions as b, generateDocumentation as c, generate as d, getProject as g };
+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;
+    options?: GenerateDocumentationOptions & {
+        /**
+         * base path to resolve `path` prop
+         */
+        basePath?: string;
+    };
+}
+
+export { type BaseTypeTableProps as B, type DocEntry as D, type GenerateDocumentationOptions as G, type GeneratedDoc as a, type GenerateOptions as b, generateDocumentation as c, generate as d, getProject as g };

package/dist/ui/index.d.ts

@@ -1,47 +1,22 @@
-import { G as GenerateDocumentationOptions } from '../base-BltLCalB.js';
+import { B as BaseTypeTableProps, G as GenerateDocumentationOptions } from '../type-table-DyymKQK8.js';
+import { ReactNode } from 'react';
 import 'ts-morph';
 
-interface AutoTypeTableProps {
+interface AutoTypeTableProps extends BaseTypeTableProps {
     /**
-     * The path to source TypeScript file.
+     * Override the function to render markdown into JSX nodes
      */
-    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;
-    options?: GenerateDocumentationOptions;
+    renderMarkdown?: typeof renderMarkdownDefault;
 }
 declare function createTypeTable(options?: GenerateDocumentationOptions): {
-    AutoTypeTable: (props: Omit<AutoTypeTableProps, 'options'>) => React.ReactNode;
+    AutoTypeTable: (props: Omit<AutoTypeTableProps, 'options'>) => ReactNode;
 };
 /**
  * **Server Component Only**
  *
  * Display properties in an exported interface via Type Table
  */
-declare function AutoTypeTable({ path, name, type, options, }: AutoTypeTableProps): Promise<React.ReactElement>;
+declare function AutoTypeTable({ renderMarkdown, ...props }: AutoTypeTableProps): Promise<ReactNode>;
+declare function renderMarkdownDefault(md: string): Promise<ReactNode>;
 
 export { AutoTypeTable, type AutoTypeTableProps, createTypeTable };

package/dist/ui/index.js

@@ -1,58 +1,40 @@
 import {
   __async,
+  __objRest,
   __spreadProps,
   __spreadValues,
-  generateDocumentation,
   getProject,
+  getTypeTableOutput,
   renderMarkdownToHast
-} from "../chunk-2L4CMRDQ.js";
+} from "../chunk-LRCT2FYJ.js";
 
 // src/ui/auto-type-table.tsx
-import fs from "node:fs/promises";
 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";
 import "server-only";
-import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function createTypeTable(options = {}) {
   var _a;
-  const project = (_a = options.project) != null ? _a : getProject(options.config);
+  const overrideOptions = __spreadProps(__spreadValues({}, options), {
+    project: (_a = options.project) != null ? _a : getProject(options.config)
+  });
   return {
     AutoTypeTable(props) {
-      return /* @__PURE__ */ jsx2(AutoTypeTable, __spreadProps(__spreadValues({}, props), { options: __spreadProps(__spreadValues({}, options), { project }) }));
+      return /* @__PURE__ */ jsx2(AutoTypeTable, __spreadProps(__spreadValues({}, props), { options: overrideOptions }));
     }
   };
 }
-function AutoTypeTable(_0) {
-  return __async(this, arguments, function* ({
-    path,
-    name,
-    type,
-    options = {}
-  }) {
-    let typeName = name;
-    let content = "";
-    if (path) {
-      content = yield fs.readFile(path).then((res) => res.toString());
-    }
-    if (type && type.split("\n").length > 1) {
-      content += `
-${type}`;
-    } else if (type) {
-      typeName != null ? typeName : typeName = "$Fumadocs";
-      content += `
-export type ${typeName} = ${type}`;
-    }
-    const output = generateDocumentation(
-      path != null ? path : "temp.ts",
-      typeName,
-      content,
-      options
-    );
-    if (name && output.length === 0)
-      throw new Error(`${name} in ${path != null ? path : "empty file"} doesn't exist`);
-    return /* @__PURE__ */ jsx2(Fragment2, { children: output.map((item) => __async(this, null, function* () {
+function AutoTypeTable(_a) {
+  return __async(this, null, function* () {
+    var _b = _a, {
+      renderMarkdown = renderMarkdownDefault
+    } = _b, props = __objRest(_b, [
+      "renderMarkdown"
+    ]);
+    const output = yield getTypeTableOutput(props);
+    return output.map((item) => __async(this, null, function* () {
       const entries = item.entries.map(
         (entry) => __async(this, null, function* () {
           return [
@@ -60,7 +42,8 @@ export type ${typeName} = ${type}`;
             {
               type: entry.type,
               description: yield renderMarkdown(entry.description),
-              default: entry.tags.default || entry.tags.defaultValue
+              default: entry.tags.default || entry.tags.defaultValue,
+              required: entry.required
             }
           ];
         })
@@ -72,10 +55,10 @@ export type ${typeName} = ${type}`;
         },
         item.name
       );
-    })) });
+    }));
   });
 }
-function renderMarkdown(md) {
+function renderMarkdownDefault(md) {
   return __async(this, null, function* () {
     return toJsxRuntime(yield renderMarkdownToHast(md), {
       Fragment: runtime.Fragment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "NextJs",
@@ -28,24 +28,29 @@
     "dist/*"
   ],
   "dependencies": {
+    "estree-util-value-to-estree": "^3.3.2",
     "fast-glob": "^3.3.3",
-    "hast-util-to-jsx-runtime": "^2.3.2",
-    "mdast-util-from-markdown": "^2.0.2",
-    "mdast-util-gfm": "^3.0.0",
-    "mdast-util-to-hast": "^13.2.0",
-    "shiki": "^2.0.3",
-    "ts-morph": "^25.0.0"
+    "hast-util-to-estree": "^3.1.2",
+    "hast-util-to-jsx-runtime": "^2.3.5",
+    "remark": "^15.0.1",
+    "remark-rehype": "^11.1.1",
+    "shiki": "^3.1.0",
+    "ts-morph": "^25.0.1",
+    "unist-util-visit": "^5.0.0"
   },
   "devDependencies": {
+    "@mdx-js/mdx": "^3.1.0",
     "@types/estree": "^1.0.6",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.3",
-    "@types/node": "22.10.7",
-    "@types/react": "19.0.7",
-    "@types/react-dom": "19.0.3",
-    "typescript": "^5.7.3",
+    "@types/node": "22.13.8",
+    "@types/react": "19.0.10",
+    "@types/react-dom": "19.0.4",
+    "typescript": "^5.8.2",
+    "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-ui": "14.7.6",
+    "fumadocs-core": "15.0.14",
+    "fumadocs-ui": "15.0.14",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {