fumadocs-typescript 4.0.14 → 5.0.0

package/dist/{base-Q18nCvFH.d.ts → base-C72MF-7Q.d.ts}

@@ -47,6 +47,11 @@ interface GenerateTypeTableOptions extends GenerateOptions {
     basePath?: string;
 }
 
+interface Cache {
+    read: (key: string) => unknown | undefined | Promise<unknown | undefined>;
+    write: (key: string, value: unknown) => void | Promise<void>;
+}
+
 interface GeneratedDoc {
     name: string;
     description: string;
@@ -89,29 +94,17 @@ interface GeneratorOptions extends TypescriptConfig {
     /**
      * cache results, note that some options are not marked as dependency.
      *
-     * @defaultValue fs
+     * @defaultValue false
      */
-    cache?: 'fs' | false;
+    cache?: Cache | false;
     project?: Project;
 }
 declare function createGenerator(config?: GeneratorOptions | Project): {
     generateDocumentation(file: {
         path: string;
         content?: string;
-    }, name: string | undefined, options?: GenerateOptions): GeneratedDoc[];
+    }, name: string | undefined, options?: GenerateOptions): Promise<GeneratedDoc[]>;
     generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions): Promise<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[];
 
-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 };
+export { type BaseTypeTableProps as B, type Cache as C, type DocEntry as D, type GenerateTypeTableOptions as G, type RawTag as R, type Generator as a, type GeneratedDoc as b, createProject as c, type GenerateOptions as d, type GeneratorOptions as e, createGenerator as f };

package/dist/{chunk-REUDVA2G.js → chunk-H4DZJVYN.js}

@@ -57,9 +57,13 @@ import {
   rehypeCode
 } from "fumadocs-core/mdx-plugins/rehype-code";
 import remarkRehype from "remark-rehype";
-import { highlightHast } from "fumadocs-core/highlight";
+import { getHighlighter } from "fumadocs-core/highlight";
 var shikiOptions = {
   lazy: true,
+  langs: ["ts", "tsx"],
+  // disable default transformers & meta parser
+  transformers: [],
+  parseMetaString: void 0,
   themes: {
     light: "github-light",
     dark: "github-dark"
@@ -68,10 +72,16 @@ var shikiOptions = {
 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), {
+    const highlighter = yield getHighlighter("js", {
+      langs: ["ts"],
+      themes: Object.values(shikiOptions.themes)
+    });
+    const nodes = highlighter.codeToHast(type, {
       lang: "ts",
-      structure: "inline"
-    }));
+      structure: "inline",
+      themes: shikiOptions.themes,
+      defaultColor: false
+    });
     return {
       type: "element",
       tagName: "span",

package/dist/index.d.ts

@@ -1,39 +1,10 @@
-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 { G as GenerateTypeTableOptions, a as Generator, B as BaseTypeTableProps, C as Cache } from './base-C72MF-7Q.js';
+export { D as DocEntry, d as GenerateOptions, b as GeneratedDoc, e as GeneratorOptions, R as RawTag, f as createGenerator, c as createProject } from './base-C72MF-7Q.js';
 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 GenerateOptions {
-    /**
-     * a root directory to resolve relative file paths
-     */
-    basePath?: string;
-    templates?: Partial<Templates>;
-}
-declare function generateMDX(generator: Generator, source: string, { basePath, templates: overrides, ...rest }?: GenerateMDXOptions): string;
-
-interface GenerateFilesOptions {
-    input: string | string[];
-    /**
-     * Output directory, or a function that returns the output path
-     */
-    output: string | ((inputPath: string) => string);
-    globOptions?: GlobOptions;
-    options?: GenerateMDXOptions;
-    /**
-     * @returns New content
-     */
-    transformOutput?: (path: string, content: string) => string;
-}
-declare function generateFiles(generator: Generator, options: GenerateFilesOptions): Promise<void>;
-
 declare function renderTypeToHast(type: string): Promise<Nodes>;
 declare function renderMarkdownToHast(md: string): Promise<Nodes>;
 
@@ -58,6 +29,9 @@ interface RemarkAutoTypeTableOptions {
     remarkStringify?: boolean;
     generator?: Generator;
 }
+interface TypeTableProps extends BaseTypeTableProps {
+    cwd?: true;
+}
 /**
  * Compile `auto-type-table` into Fumadocs UI compatible TypeTable
  *
@@ -65,4 +39,6 @@ interface RemarkAutoTypeTableOptions {
  */
 declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
 
-export { DocEntry, type GenerateFilesOptions, type GenerateMDXOptions, GenerateOptions, GeneratedDoc, Generator, type RemarkAutoTypeTableOptions, generateFiles, generateMDX, remarkAutoTypeTable, renderMarkdownToHast };
+declare function createFileSystemGeneratorCache(dir: string): Cache;
+
+export { Cache, Generator, type RemarkAutoTypeTableOptions, type TypeTableProps, createFileSystemGeneratorCache, remarkAutoTypeTable, renderMarkdownToHast };

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   parseTags,
   renderMarkdownToHast,
   renderTypeToHast
-} from "./chunk-REUDVA2G.js";
+} from "./chunk-H4DZJVYN.js";
 
 // src/lib/base.ts
 import {
@@ -25,7 +25,7 @@ function createProject(options = {}) {
 }
 
 // src/lib/base.ts
-import fs3 from "fs";
+import fs2 from "fs/promises";
 
 // src/lib/type-table.ts
 import * as fs from "fs/promises";
@@ -47,7 +47,7 @@ ${type}`;
       content += `
 export type ${typeName} = ${type}`;
     }
-    const output = gen.generateDocumentation(
+    const output = yield gen.generateDocumentation(
       { path: file != null ? file : "temp.ts", content },
       typeName,
       options
@@ -58,36 +58,8 @@ export type ${typeName} = ${type}`;
   });
 }
 
-// src/lib/cache.ts
-import fs2 from "fs";
-import { createHash } from "crypto";
-import path from "path";
-function createCache() {
-  const dir = path.join(process.cwd(), ".next/fumadocs-typescript");
-  try {
-    fs2.mkdirSync(dir, { recursive: true });
-  } catch (e) {
-  }
-  return {
-    write(input, data) {
-      const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
-      fs2.writeFileSync(path.join(dir, `${hash}.json`), JSON.stringify(data));
-    },
-    read(input) {
-      const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
-      try {
-        return JSON.parse(
-          fs2.readFileSync(path.join(dir, `${hash}.json`)).toString()
-        );
-      } catch (e) {
-        return;
-      }
-    }
-  };
-}
-
 // src/lib/base.ts
-import path2 from "path";
+import path from "path";
 
 // src/lib/get-simple-form.ts
 import * as ts from "ts-morph";
@@ -150,12 +122,10 @@ function dedupe(arr) {
 
 // src/lib/base.ts
 function createGenerator(config) {
-  var _a;
   const options = config instanceof Project2 ? {
     project: config
   } : config;
-  const cacheType = (_a = options == null ? void 0 : options.cache) != null ? _a : process.env.NODE_ENV !== "development" ? "fs" : false;
-  const cache = cacheType === "fs" ? createCache() : null;
+  const cache = (options == null ? void 0 : options.cache) ? options.cache : null;
   let instance;
   function getProject() {
     var _a2;
@@ -164,38 +134,35 @@ function createGenerator(config) {
   }
   return {
     generateDocumentation(file, name, options2) {
-      var _a2;
-      const content = (_a2 = file.content) != null ? _a2 : fs3.readFileSync(path2.resolve(file.path)).toString();
-      const cacheKey = `${file.path}:${name}:${content}`;
-      if (cache) {
-        const cached = cache.read(cacheKey);
-        if (cached) return cached;
-      }
-      const sourceFile = getProject().createSourceFile(file.path, content, {
-        overwrite: true
+      return __async(this, null, function* () {
+        var _a2;
+        const content = (_a2 = file.content) != null ? _a2 : (yield fs2.readFile(path.resolve(file.path))).toString();
+        const cacheKey = `${file.path}:${name}:${content}`;
+        if (cache) {
+          const cached = yield cache.read(cacheKey);
+          if (cached) return cached;
+        }
+        const sourceFile = getProject().createSourceFile(file.path, 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(getProject(), k, d[0], options2));
+        }
+        void (cache == null ? void 0 : cache.write(cacheKey, out));
+        return out;
       });
-      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(getProject(), k, d[0], options2));
-      }
-      cache == null ? void 0 : cache.write(cacheKey, out);
-      return out;
     },
     generateTypeTable(props, options2) {
       return getTypeTableOutput(this, props, options2);
     }
   };
 }
-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 = {
@@ -267,89 +234,10 @@ function getDocEntry(prop, context) {
   return entry;
 }
 
-// src/lib/mdx.ts
-import * as path3 from "path";
-var regex = new RegExp("^---type-table---\\r?\\n(?<file>.+?)(?:#(?<name>.+))?\\r?\\n---end---$", "gm");
-var defaultTemplates = {
-  block: (doc, c) => `### ${doc.name}
-
-${doc.description}
-
-<div className='*:border-b [&>*:last-child]:border-b-0'>${c}</div>`,
-  property: (c) => `<div className='text-sm text-fd-muted-foreground py-4'>
-
-<div className="flex flex-row items-center gap-4">
-  <code className="text-sm">${c.name}</code>
-  <code className="text-fd-muted-foreground">{${JSON.stringify(c.simplifiedType)}}</code>
-</div>
-
-Full Type: <code className="text-fd-muted-foreground">{${JSON.stringify(c.type)}}</code>
-
-${c.description || "No Description"}
-
-${c.tags.map((tag) => `- ${tag.name}:
-${replaceJsDocLinks(tag.text)}`).join("\n")}
-
-</div>`
-};
-function generateMDX(generator, source, _a = {}) {
-  var _b = _a, { basePath = "./", templates: overrides } = _b, rest = __objRest(_b, ["basePath", "templates"]);
-  const templates = __spreadValues(__spreadValues({}, defaultTemplates), overrides);
-  return source.replace(regex, (...args) => {
-    const groups = args[args.length - 1];
-    const file = path3.resolve(basePath, groups.file);
-    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");
-  });
-}
-function replaceJsDocLinks(md) {
-  return md.replace(new RegExp("{@link (?<link>[^}]*)}", "g"), "$1");
-}
-
-// src/lib/file.ts
-import * as path4 from "path";
-import { mkdir, writeFile, readFile as readFile2 } from "fs/promises";
-import { glob } from "tinyglobby";
-function generateFiles(generator, options) {
-  return __async(this, null, function* () {
-    const files = yield glob(options.input, options.globOptions);
-    const produce = files.map((file) => __async(null, null, function* () {
-      const absolutePath = path4.resolve(file);
-      const outputPath = typeof options.output === "function" ? options.output(file) : path4.resolve(
-        options.output,
-        `${path4.basename(file, path4.extname(file))}.mdx`
-      );
-      const content = (yield readFile2(absolutePath)).toString();
-      let result = generateMDX(generator, content, __spreadValues({
-        basePath: path4.dirname(absolutePath)
-      }, options.options));
-      if (options.transformOutput) {
-        result = options.transformOutput(outputPath, result);
-      }
-      yield write(outputPath, result);
-      console.log(`Generated: ${outputPath}`);
-    }));
-    yield Promise.all(produce);
-  });
-}
-function write(file, content) {
-  return __async(this, null, function* () {
-    yield mkdir(path4.dirname(file), { recursive: true });
-    yield writeFile(file, content);
-  });
-}
-
 // 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 objectBuilder() {
   const out = {
     type: "ObjectExpression",
@@ -389,10 +277,10 @@ function buildTypeProp(_0, _1) {
     function onItem(entry) {
       return __async(this, null, function* () {
         const node = objectBuilder();
+        const tags = parseTags(entry.tags);
         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)
@@ -449,74 +337,102 @@ function remarkAutoTypeTable(config = {}) {
   } = config;
   return (tree, file) => __async(null, null, function* () {
     const queue = [];
-    const defaultBasePath = file.path ? dirname2(file.path) : void 0;
+    function run(node, props) {
+      return __async(this, null, function* () {
+        let basePath = props.cwd ? file.cwd : generateOptions.basePath;
+        if (file.dirname) {
+          basePath != null ? basePath : basePath = file.dirname;
+        }
+        const output = yield generator.generateTypeTable(props, __spreadProps(__spreadValues({}, generateOptions), {
+          basePath
+        }));
+        const rendered = output.map((doc) => __async(null, null, function* () {
+          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: yield buildTypeProp(doc.entries, config)
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            ],
+            children: []
+          };
+        }));
+        Object.assign(node, {
+          type: "root",
+          attributes: [],
+          children: yield Promise.all(rendered)
+        });
+      });
+    }
     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")
+        if (attr.type !== "mdxJsxAttribute" || typeof attr.value !== "string" && attr.value !== null)
           throw new Error(
-            "`auto-type-table` does not support non-string attributes"
+            "`auto-type-table` only support string & boolean attributes"
           );
         props[attr.name] = attr.value;
       }
-      function run() {
-        return __async(this, null, function* () {
-          var _a;
-          const output = yield generator.generateTypeTable(
-            props,
-            __spreadProps(__spreadValues({}, generateOptions), {
-              basePath: (_a = generateOptions.basePath) != null ? _a : defaultBasePath
-            })
-          );
-          const rendered = output.map((doc) => __async(null, null, function* () {
-            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: yield buildTypeProp(doc.entries, config)
-                          }
-                        ]
-                      }
-                    }
-                  }
-                }
-              ],
-              children: []
-            };
-          }));
-          Object.assign(node, {
-            type: "root",
-            attributes: [],
-            children: yield Promise.all(rendered)
-          });
-        });
-      }
-      queue.push(run());
+      queue.push(run(node, props));
       return "skip";
     });
     yield Promise.all(queue);
   });
 }
+
+// src/cache/fs-cache.ts
+import fs3 from "fs/promises";
+import { createHash } from "crypto";
+import path2 from "path";
+function createFileSystemGeneratorCache(dir) {
+  dir = path2.resolve(dir);
+  const initDirPromise = fs3.mkdir(dir, { recursive: true }).catch(() => {
+  });
+  return {
+    write(input, data) {
+      return __async(this, null, function* () {
+        const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+        yield initDirPromise;
+        yield fs3.writeFile(path2.join(dir, `${hash}.json`), JSON.stringify(data));
+      });
+    },
+    read(input) {
+      return __async(this, null, function* () {
+        const hash = createHash("SHA256").update(input).digest("hex").slice(0, 12);
+        try {
+          return JSON.parse(
+            (yield fs3.readFile(path2.join(dir, `${hash}.json`))).toString()
+          );
+        } catch (e) {
+          return;
+        }
+      });
+    }
+  };
+}
 export {
+  createFileSystemGeneratorCache,
   createGenerator,
   createProject,
-  generateDocumentation,
-  generateFiles,
-  generateMDX,
   remarkAutoTypeTable,
   renderMarkdownToHast
 };

package/dist/ui/index.d.ts

@@ -1,6 +1,6 @@
 import * as runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { B as BaseTypeTableProps, b as Generator, c as GenerateTypeTableOptions } from '../base-Q18nCvFH.js';
+import { B as BaseTypeTableProps, a as Generator, G as GenerateTypeTableOptions } from '../base-C72MF-7Q.js';
 import 'ts-morph';
 
 type AutoTypeTableProps = BaseTypeTableProps;

package/dist/ui/index.js

@@ -6,7 +6,7 @@ import {
   parseTags,
   renderMarkdownToHast,
   renderTypeToHast
-} from "../chunk-REUDVA2G.js";
+} from "../chunk-H4DZJVYN.js";
 
 // src/ui/auto-type-table.tsx
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-typescript",
-  "version": "4.0.14",
+  "version": "5.0.0",
   "description": "Typescript Integration for Fumadocs",
   "keywords": [
     "NextJs",
@@ -48,8 +48,8 @@
     "typescript": "^5.9.3",
     "unified": "^11.0.5",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "16.2.4",
-    "fumadocs-ui": "16.2.4",
+    "fumadocs-core": "16.3.2",
+    "fumadocs-ui": "16.3.2",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {