fumadocs-typescript 3.1.0 → 4.0.1

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

@@ -50,88 +50,6 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// 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 {
-  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 { remark } from "remark";
 import {
@@ -162,17 +80,9 @@ function renderMarkdownToHast(md) {
 // src/utils/type-table.ts
 import * as fs from "node:fs/promises";
 import { join } from "node:path";
-function getTypeTableOutput(_a) {
+function getTypeTableOutput(gen, _a, options) {
   return __async(this, null, function* () {
-    var _b = _a, {
-      name,
-      type,
-      options
-    } = _b, props = __objRest(_b, [
-      "name",
-      "type",
-      "options"
-    ]);
+    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 = "";
@@ -187,10 +97,9 @@ ${type}`;
       content += `
 export type ${typeName} = ${type}`;
     }
-    const output = generateDocumentation(
-      file != null ? file : "temp.ts",
+    const output = gen.generateDocumentation(
+      { path: file != null ? file : "temp.ts", content },
       typeName,
-      content,
       options
     );
     if (name && output.length === 0)
@@ -204,9 +113,6 @@ export {
   __spreadProps,
   __objRest,
   __async,
-  getProject,
-  generateDocumentation,
-  generate,
   renderMarkdownToHast,
   getTypeTableOutput
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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 { 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';
@@ -10,14 +10,14 @@ 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[];
@@ -32,7 +32,7 @@ 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>;
 
@@ -47,15 +47,20 @@ interface RemarkAutoTypeTableOptions {
     outputName?: string;
     renderMarkdown?: typeof renderMarkdownToHast;
     /**
-     * Override some type table props
+     * Customise type table generation
      */
-    options?: BaseTypeTableProps['options'];
+    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, }?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
+declare function remarkAutoTypeTable({ name, outputName, renderMarkdown, options, remarkStringify, generator, }?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
 
-export { DocEntry, GenerateDocumentationOptions, type GenerateFilesOptions, type GenerateMDXOptions, GeneratedDoc, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };
+export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, Generator, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };

package/dist/index.js

@@ -3,16 +3,111 @@ import {
   __objRest,
   __spreadProps,
   __spreadValues,
-  generate,
-  generateDocumentation,
-  getProject,
   getTypeTableOutput,
   renderMarkdownToHast
-} from "./chunk-LRCT2FYJ.js";
+} from "./chunk-2WGVCLFC.js";
+
+// 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";
-import fs from "node:fs";
 var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
 var defaultTemplates = {
   block: (doc, c) => `### ${doc.name}
@@ -34,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");
@@ -59,11 +153,9 @@ function replaceJsDocLinks(md) {
 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(
@@ -71,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);
       }
@@ -97,31 +187,12 @@ 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
+      default: entry.tags.default || entry.tags.defaultValue,
+      required: entry.required
     });
     if (entry.description) {
       const hast = toEstree(yield renderMarkdown(entry.description), {
@@ -158,10 +229,10 @@ function remarkAutoTypeTable({
   name = "auto-type-table",
   outputName = "TypeTable",
   renderMarkdown = renderMarkdownToHast,
-  options = {}
+  options = {},
+  remarkStringify = true,
+  generator = createGenerator()
 } = {}) {
-  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;
@@ -178,12 +249,13 @@ function remarkAutoTypeTable({
       }
       function run() {
         return __async(this, null, function* () {
-          const output = yield getTypeTableOutput(__spreadProps(__spreadValues({}, props), {
-            options: __spreadProps(__spreadValues({}, options), {
-              project,
+          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))
@@ -192,22 +264,30 @@ function remarkAutoTypeTable({
               type: "mdxJsxFlowElement",
               name: outputName,
               attributes: [
-                expressionToAttribute("type", {
-                  type: "ObjectExpression",
-                  properties
-                })
+                {
+                  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
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
               ],
-              data: {
-                // for Fumadocs `remarkStructure`
-                _string: [
-                  doc.name,
-                  doc.description,
-                  ...doc.entries.flatMap((entry) => [
-                    `${entry.name}: ${entry.type}`,
-                    entry.description
-                  ])
-                ]
-              },
               children: []
             };
           }));
@@ -225,7 +305,7 @@ function remarkAutoTypeTable({
   });
 }
 export {
-  generate,
+  createGenerator,
   generateDocumentation,
   generateFiles,
   generateMDX,

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

@@ -39,18 +39,25 @@ interface GenerateOptions {
      */
     transform?: Transformer;
 }
-interface GenerateDocumentationOptions extends GenerateOptions {
+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;
-}
-/**
- * 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;
+}): GeneratedDoc[];
 
 interface BaseTypeTableProps {
     /**
@@ -83,12 +90,12 @@ interface BaseTypeTableProps {
      * ```
      */
     type?: string;
-    options?: GenerateDocumentationOptions & {
-        /**
-         * base path to resolve `path` prop
-         */
-        basePath?: string;
-    };
+}
+interface GenerateTypeTableOptions extends GenerateOptions {
+    /**
+     * 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 };
+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,22 +1,14 @@
-import { B as BaseTypeTableProps, G as GenerateDocumentationOptions } from '../type-table-DyymKQK8.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 extends BaseTypeTableProps {
-    /**
-     * Override the function to render markdown into JSX nodes
-     */
+type AutoTypeTableProps = BaseTypeTableProps;
+declare function AutoTypeTable({ generator, options, renderMarkdown, ...props }: AutoTypeTableProps & {
+    generator: Generator;
     renderMarkdown?: typeof renderMarkdownDefault;
-}
-declare function createTypeTable(options?: GenerateDocumentationOptions): {
-    AutoTypeTable: (props: Omit<AutoTypeTableProps, 'options'>) => ReactNode;
-};
-/**
- * **Server Component Only**
- *
- * Display properties in an exported interface via Type Table
- */
-declare function AutoTypeTable({ renderMarkdown, ...props }: AutoTypeTableProps): Promise<ReactNode>;
+    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

@@ -3,10 +3,9 @@ import {
   __objRest,
   __spreadProps,
   __spreadValues,
-  getProject,
   getTypeTableOutput,
   renderMarkdownToHast
-} from "../chunk-LRCT2FYJ.js";
+} from "../chunk-2WGVCLFC.js";
 
 // src/ui/auto-type-table.tsx
 import { TypeTable } from "fumadocs-ui/components/type-table";
@@ -15,25 +14,18 @@ import * as runtime from "react/jsx-runtime";
 import defaultMdxComponents from "fumadocs-ui/mdx";
 import "server-only";
 import { jsx as jsx2 } from "react/jsx-runtime";
-function createTypeTable(options = {}) {
-  var _a;
-  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: overrideOptions }));
-    }
-  };
-}
 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(props);
+    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* () {
@@ -69,6 +61,5 @@ function renderMarkdownDefault(md) {
   });
 }
 export {
-  AutoTypeTable,
-  createTypeTable
+  AutoTypeTable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "3.1.0",
+  "version": "4.0.1",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "NextJs",
@@ -30,28 +30,28 @@
   "dependencies": {
     "estree-util-value-to-estree": "^3.3.2",
     "fast-glob": "^3.3.3",
-    "hast-util-to-estree": "^3.1.2",
-    "hast-util-to-jsx-runtime": "^2.3.5",
+    "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.1.0",
+    "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/estree": "^1.0.7",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.3",
-    "@types/node": "22.13.8",
-    "@types/react": "19.0.10",
+    "@types/node": "22.13.14",
+    "@types/react": "19.0.12",
     "@types/react-dom": "19.0.4",
     "typescript": "^5.8.2",
     "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "15.0.14",
-    "fumadocs-ui": "15.0.14",
-    "tsconfig": "0.0.0"
+    "fumadocs-ui": "15.2.1",
+    "tsconfig": "0.0.0",
+    "fumadocs-core": "15.2.1"
   },
   "peerDependencies": {
     "typescript": "*"