fumadocs-typescript 3.0.4 → 4.0.0

package/dist/chunk-2WGVCLFC.js

@@ -0,0 +1,118 @@
+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,
+  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* () {
+    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(gen, _a, options) {
+  return __async(this, null, function* () {
+    var _b = _a, { name, type } = _b, props = __objRest(_b, ["name", "type"]);
+    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();
+    }
+    if (type && type.split("\n").length > 1) {
+      content += `
+${type}`;
+    } else if (type) {
+      typeName != null ? typeName : typeName = "$Fumadocs";
+      content += `
+export type ${typeName} = ${type}`;
+    }
+    const output = gen.generateDocumentation(
+      { path: file != null ? file : "temp.ts", content },
+      typeName,
+      options
+    );
+    if (name && output.length === 0)
+      throw new Error(`${name} in ${file != null ? file : "empty file"} doesn't exist`);
+    return output;
+  });
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __async,
+  renderMarkdownToHast,
+  getTypeTableOutput
+};

package/dist/index.d.ts

@@ -1,21 +1,23 @@
-import { G as GenerateDocumentationOptions, a as GeneratedDoc, D as DocEntry } from './base-BaB_XiY6.js';
-export { b as GenerateOptions, d as generate, c as generateDocumentation, g as getProject } from './base-BaB_XiY6.js';
+import { G as GenerateOptions, a as GeneratedDoc, D as DocEntry, b as Generator, c as GenerateTypeTableOptions } from './type-table-Duzly_SK.js';
+export { d as createGenerator, e as generateDocumentation, g as getProject } from './type-table-Duzly_SK.js';
 import fg from 'fast-glob';
 import { Nodes } from 'hast';
+import { Root } from 'mdast';
+import { Transformer } from 'unified';
 import 'ts-morph';
 
 interface Templates {
     block: (doc: GeneratedDoc, children: string) => string;
     property: (entry: DocEntry) => string;
 }
-interface GenerateMDXOptions extends GenerateDocumentationOptions {
+interface GenerateMDXOptions extends GenerateOptions {
     /**
      * a root directory to resolve relative file paths
      */
     basePath?: string;
     templates?: Partial<Templates>;
 }
-declare function generateMDX(source: string, { basePath, templates: overrides, ...rest }?: GenerateMDXOptions): string;
+declare function generateMDX(generator: Generator, source: string, { basePath, templates: overrides, ...rest }?: GenerateMDXOptions): string;
 
 interface GenerateFilesOptions {
     input: string | string[];
@@ -30,8 +32,35 @@ interface GenerateFilesOptions {
      */
     transformOutput?: (path: string, content: string) => string;
 }
-declare function generateFiles(options: GenerateFilesOptions): Promise<void>;
+declare function generateFiles(generator: Generator, 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;
+    /**
+     * Customise type table generation
+     */
+    options?: GenerateTypeTableOptions;
+    /**
+     * generate required `value` property for `remark-stringify`
+     */
+    remarkStringify?: boolean;
+    generator?: Generator;
+}
+/**
+ * Compile `auto-type-table` into Fumadocs UI compatible TypeTable
+ *
+ * MDX is required to use this plugin.
+ */
+declare function remarkAutoTypeTable({ name, outputName, renderMarkdown, options, remarkStringify, generator, }?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
+
+export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, Generator, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };

package/dist/index.js

@@ -3,15 +3,111 @@ import {
   __objRest,
   __spreadProps,
   __spreadValues,
-  generate,
-  generateDocumentation,
-  getProject,
+  getTypeTableOutput,
   renderMarkdownToHast
-} from "./chunk-PRWE5YDY.js";
+} from "./chunk-2WGVCLFC.js";
 
-// src/generate/mdx.ts
-import * as path from "node:path";
+// src/lib/base.ts
+import {
+  Project as Project2,
+  ts
+} from "ts-morph";
+
+// src/get-project.ts
+import { Project } from "ts-morph";
+function getProject(options = {}) {
+  var _a;
+  return new Project({
+    tsConfigFilePath: (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
+    skipAddingFilesFromTsConfig: true
+  });
+}
+
+// src/lib/base.ts
 import fs from "node:fs";
+function createGenerator(config) {
+  const project = config instanceof Project2 ? config : getProject(config);
+  return {
+    generateDocumentation(file, name, options = {}) {
+      var _a;
+      const sourceFile = project.createSourceFile(
+        file.path,
+        (_a = file.content) != null ? _a : fs.readFileSync(file.path).toString(),
+        {
+          overwrite: true
+        }
+      );
+      const out = [];
+      for (const [k, d] of sourceFile.getExportedDeclarations()) {
+        if (name && name !== k) continue;
+        if (d.length > 1)
+          console.warn(
+            `export ${k} should not have more than one type declaration.`
+          );
+        out.push(generate(project, k, d[0], options));
+      }
+      return out;
+    }
+  };
+}
+function generateDocumentation(file, name, content, options = {}) {
+  var _a;
+  const gen = createGenerator((_a = options.project) != null ? _a : options.config);
+  return gen.generateDocumentation({ path: file, content }, name, options);
+}
+function generate(program, name, declaration, { allowInternal = false, transform }) {
+  var _a;
+  const entryContext = {
+    transform,
+    program,
+    type: declaration.getType(),
+    declaration
+  };
+  const comment = (_a = declaration.getSymbol()) == null ? void 0 : _a.compilerSymbol.getDocumentationComment(
+    program.getTypeChecker().compilerObject
+  );
+  return {
+    name,
+    description: comment ? ts.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;
+  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.getNonNullableType().getText(void 0, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+  if (subType.getAliasSymbol() && subType.getAliasTypeArguments().length === 0) {
+    typeName = (_b = (_a = subType.getAliasSymbol()) == null ? void 0 : _a.getEscapedName()) != null ? _b : typeName;
+  }
+  if ("remarks" in tags) {
+    typeName = (_d = (_c = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _c[1]) != null ? _d : typeName;
+  }
+  const entry = {
+    name: prop.getName(),
+    description: ts.displayPartsToString(
+      prop.compilerSymbol.getDocumentationComment(
+        program.getTypeChecker().compilerObject
+      )
+    ),
+    tags,
+    type: typeName,
+    required: !prop.isOptional()
+  };
+  transform == null ? void 0 : transform.call(context, entry, subType, prop);
+  return entry;
+}
+
+// src/lib/mdx.ts
+import * as path from "node:path";
 var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
 var defaultTemplates = {
   block: (doc, c) => `### ${doc.name}
@@ -33,18 +129,17 @@ ${replaceJsDocLinks(value)}`).join("\n")}
 
 </div>`
 };
-function generateMDX(source, _a = {}) {
+function generateMDX(generator, source, _a = {}) {
   var _b = _a, { basePath = "./", templates: overrides } = _b, rest = __objRest(_b, ["basePath", "templates"]);
-  var _a2;
   const templates = __spreadValues(__spreadValues({}, defaultTemplates), overrides);
-  const project = (_a2 = rest.project) != null ? _a2 : getProject(rest.config);
   return source.replace(regex, (...args) => {
     const groups = args[args.length - 1];
     const file = path.resolve(basePath, groups.file);
-    const content = fs.readFileSync(file);
-    const docs = generateDocumentation(file, groups.name, content.toString(), __spreadProps(__spreadValues({}, rest), {
-      project
-    }));
+    const docs = generator.generateDocumentation(
+      { path: file },
+      groups.name,
+      rest
+    );
     return docs.map(
       (doc) => templates.block(doc, doc.entries.map(templates.property).join("\n"))
     ).join("\n\n");
@@ -54,15 +149,13 @@ 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";
-function generateFiles(options) {
+function generateFiles(generator, options) {
   return __async(this, null, function* () {
-    var _a, _b, _c;
     const files = yield fg(options.input, options.globOptions);
-    const project = (_c = (_a = options.options) == null ? void 0 : _a.project) != null ? _c : getProject((_b = options.options) == null ? void 0 : _b.config);
     const produce = files.map((file) => __async(this, null, function* () {
       const absolutePath = path2.resolve(file);
       const outputPath = typeof options.output === "function" ? options.output(file) : path2.resolve(
@@ -70,11 +163,9 @@ function generateFiles(options) {
         `${path2.basename(file, path2.extname(file))}.mdx`
       );
       const content = (yield readFile(absolutePath)).toString();
-      let result = generateMDX(content, __spreadProps(__spreadValues({
+      let result = generateMDX(generator, content, __spreadValues({
         basePath: path2.dirname(absolutePath)
-      }, options.options), {
-        project
-      }));
+      }, options.options));
       if (options.transformOutput) {
         result = options.transformOutput(outputPath, result);
       }
@@ -90,11 +181,134 @@ 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 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 = {},
+  remarkStringify = true,
+  generator = createGenerator()
+} = {}) {
+  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(
+            generator,
+            props,
+            __spreadProps(__spreadValues({}, options), {
+              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: [
+                {
+                  type: "mdxJsxAttribute",
+                  name: "type",
+                  value: {
+                    type: "mdxJsxAttributeValueExpression",
+                    value: remarkStringify ? JSON.stringify(doc, null, 2) : "",
+                    data: {
+                      estree: {
+                        type: "Program",
+                        sourceType: "module",
+                        body: [
+                          {
+                            type: "ExpressionStatement",
+                            expression: {
+                              type: "ObjectExpression",
+                              properties
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ],
+              children: []
+            };
+          }));
+          Object.assign(node, {
+            type: "root",
+            attributes: [],
+            children: yield Promise.all(rendered)
+          });
+        });
+      }
+      queue.push(run());
+      return "skip";
+    });
+    yield Promise.all(queue);
+  });
+}
 export {
-  generate,
+  createGenerator,
   generateDocumentation,
   generateFiles,
   generateMDX,
   getProject,
+  remarkAutoTypeTable,
   renderMarkdownToHast
 };

package/dist/type-table-Duzly_SK.d.ts

@@ -0,0 +1,101 @@
+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 getProject(options?: TypescriptConfig): Project;
+
+interface GeneratedDoc {
+    name: string;
+    description: string;
+    entries: DocEntry[];
+}
+interface DocEntry {
+    name: string;
+    description: string;
+    type: string;
+    tags: Record<string, string>;
+    required: boolean;
+}
+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>;
+declare function createGenerator(config?: TypescriptConfig | Project): {
+    generateDocumentation(file: {
+        path: string;
+        content?: string;
+    }, name: string | undefined, options?: GenerateOptions): GeneratedDoc[];
+};
+/**
+ * Generate documentation for properties in an exported type/interface
+ *
+ * @deprecated use `createGenerator` instead
+ */
+declare function generateDocumentation(file: string, name: string | undefined, content: string, options?: GenerateOptions & {
+    /**
+     * Typescript configurations
+     */
+    config?: TypescriptConfig;
+    project?: Project;
+}): GeneratedDoc[];
+
+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;
+}
+
+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, createGenerator as d, generateDocumentation as e, getProject as g };

package/dist/ui/index.d.ts

@@ -1,47 +1,14 @@
-import { G as GenerateDocumentationOptions } from '../base-BaB_XiY6.js';
+import * as runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { B as BaseTypeTableProps, b as Generator, c as GenerateTypeTableOptions } from '../type-table-Duzly_SK.js';
 import 'ts-morph';
 
-interface AutoTypeTableProps {
-    /**
-     * 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;
-}
-declare function createTypeTable(options?: GenerateDocumentationOptions): {
-    AutoTypeTable: (props: Omit<AutoTypeTableProps, 'options'>) => React.ReactNode;
-};
-/**
- * **Server Component Only**
- *
- * Display properties in an exported interface via Type Table
- */
-declare function AutoTypeTable({ path, name, type, options, }: AutoTypeTableProps): Promise<React.ReactElement>;
+type AutoTypeTableProps = BaseTypeTableProps;
+declare function AutoTypeTable({ generator, options, renderMarkdown, ...props }: AutoTypeTableProps & {
+    generator: Generator;
+    renderMarkdown?: typeof renderMarkdownDefault;
+    options?: GenerateTypeTableOptions;
+}): Promise<Promise<runtime.JSX.Element>[]>;
+declare function renderMarkdownDefault(md: string): Promise<ReactNode>;
 
-export { AutoTypeTable, type AutoTypeTableProps, createTypeTable };
+export { AutoTypeTable, type AutoTypeTableProps };

package/dist/ui/index.js

@@ -1,58 +1,32 @@
 import {
   __async,
+  __objRest,
   __spreadProps,
   __spreadValues,
-  generateDocumentation,
-  getProject,
+  getTypeTableOutput,
   renderMarkdownToHast
-} from "../chunk-PRWE5YDY.js";
+} from "../chunk-2WGVCLFC.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";
-function createTypeTable(options = {}) {
-  var _a;
-  const project = (_a = options.project) != null ? _a : getProject(options.config);
-  return {
-    AutoTypeTable(props) {
-      return /* @__PURE__ */ jsx2(AutoTypeTable, __spreadProps(__spreadValues({}, props), { options: __spreadProps(__spreadValues({}, options), { project }) }));
-    }
-  };
-}
-function AutoTypeTable(_0) {
-  return __async(this, arguments, function* ({
-    path,
-    name,
-    type,
-    options = {}
-  }) {
-    let typeName = name;
-    let content = "";
-    if (path) {
-      content = (yield fs.readFile(path)).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* () {
+import { jsx as jsx2 } from "react/jsx-runtime";
+function AutoTypeTable(_a) {
+  return __async(this, null, function* () {
+    var _b = _a, {
+      generator,
+      options = {},
+      renderMarkdown = renderMarkdownDefault
+    } = _b, props = __objRest(_b, [
+      "generator",
+      "options",
+      "renderMarkdown"
+    ]);
+    const output = yield getTypeTableOutput(generator, props, options);
+    return output.map((item) => __async(this, null, function* () {
       const entries = item.entries.map(
         (entry) => __async(this, null, function* () {
           return [
@@ -73,10 +47,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,
@@ -87,6 +61,5 @@ function renderMarkdown(md) {
   });
 }
 export {
-  AutoTypeTable,
-  createTypeTable
+  AutoTypeTable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "3.0.4",
+  "version": "4.0.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.3",
-    "mdast-util-from-markdown": "^2.0.2",
-    "mdast-util-gfm": "^3.1.0",
-    "mdast-util-to-hast": "^13.2.0",
-    "shiki": "^3.0.0",
-    "ts-morph": "^25.0.1"
+    "hast-util-to-estree": "^3.1.3",
+    "hast-util-to-jsx-runtime": "^2.3.6",
+    "remark": "^15.0.1",
+    "remark-rehype": "^11.1.1",
+    "shiki": "^3.2.1",
+    "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.13.4",
-    "@types/react": "19.0.10",
+    "@types/node": "22.13.11",
+    "@types/react": "19.0.12",
     "@types/react-dom": "19.0.4",
-    "typescript": "^5.7.3",
+    "typescript": "^5.8.2",
+    "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-ui": "15.0.13",
+    "fumadocs-core": "15.1.3",
+    "fumadocs-ui": "15.1.3",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/dist/base-BaB_XiY6.d.ts

@@ -1,55 +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 getProject(options?: TypescriptConfig): Project;
-
-interface GeneratedDoc {
-    name: string;
-    description: string;
-    entries: DocEntry[];
-}
-interface DocEntry {
-    name: string;
-    description: string;
-    type: string;
-    tags: Record<string, string>;
-    required: boolean;
-}
-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;
-}
-interface GenerateDocumentationOptions extends GenerateOptions {
-    /**
-     * Typescript configurations
-     */
-    config?: TypescriptConfig;
-    project?: Project;
-}
-/**
- * Generate documentation for properties in an exported type/interface
- */
-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 };

package/dist/chunk-PRWE5YDY.js

@@ -1,206 +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/get-project.ts
-import { Project } from "ts-morph";
-function getProject(options = {}) {
-  var _a;
-  return new Project({
-    tsConfigFilePath: (_a = options.tsconfigPath) != null ? _a : "./tsconfig.json",
-    skipAddingFilesFromTsConfig: true
-  });
-}
-
-// src/generate/base.ts
-import {
-  ts
-} from "ts-morph";
-function generateDocumentation(file, name, content, options = {}) {
-  var _a;
-  const project = (_a = options.project) != null ? _a : getProject(options.config);
-  const sourceFile = project.createSourceFile(file, content, {
-    overwrite: true
-  });
-  const out = [];
-  for (const [k, d] of sourceFile.getExportedDeclarations()) {
-    if (name && name !== k) continue;
-    if (d.length > 1)
-      console.warn(
-        `export ${k} should not have more than one type declaration.`
-      );
-    out.push(generate(project, k, d[0], options));
-  }
-  return out;
-}
-function generate(program, name, declaration, { allowInternal = false, transform }) {
-  var _a;
-  const entryContext = {
-    transform,
-    program,
-    type: declaration.getType(),
-    declaration
-  };
-  const comment = (_a = declaration.getSymbol()) == null ? void 0 : _a.compilerSymbol.getDocumentationComment(
-    program.getTypeChecker().compilerObject
-  );
-  return {
-    name,
-    description: comment ? ts.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;
-  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.getNonNullableType().getText(void 0, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-  if (subType.getAliasSymbol() && subType.getAliasTypeArguments().length === 0) {
-    typeName = (_b = (_a = subType.getAliasSymbol()) == null ? void 0 : _a.getEscapedName()) != null ? _b : typeName;
-  }
-  if ("remarks" in tags) {
-    typeName = (_d = (_c = new RegExp("^`(?<name>.+)`").exec(tags.remarks)) == null ? void 0 : _c[1]) != null ? _d : typeName;
-  }
-  const entry = {
-    name: prop.getName(),
-    description: ts.displayPartsToString(
-      prop.compilerSymbol.getDocumentationComment(
-        program.getTypeChecker().compilerObject
-      )
-    ),
-    tags,
-    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";
-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
-              );
-            }
-          }))
-        );
-      });
-    }
-    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;
-        }
-      }
-    });
-  });
-}
-
-export {
-  __spreadValues,
-  __spreadProps,
-  __objRest,
-  __async,
-  getProject,
-  generateDocumentation,
-  generate,
-  renderMarkdownToHast
-};