fumadocs-typescript 5.0.0 → 5.1.0

package/dist/base-Dvhn4vZx.d.ts

@@ -0,0 +1,114 @@
+import { ExportedDeclarations, Project, Symbol, Type } from "ts-morph";
+
+//#region src/create-project.d.ts
+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 createProject(options?: TypescriptConfig): Project;
+//#endregion
+//#region src/lib/type-table.d.ts
+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;
+}
+//#endregion
+//#region src/cache/index.d.ts
+interface Cache {
+  read: (key: string) => unknown | undefined | Promise<unknown | undefined>;
+  write: (key: string, value: unknown) => void | Promise<void>;
+}
+//#endregion
+//#region src/lib/base.d.ts
+interface GeneratedDoc {
+  name: string;
+  description: string;
+  entries: DocEntry[];
+}
+interface DocEntry {
+  name: string;
+  description: string;
+  type: string;
+  simplifiedType: string;
+  tags: RawTag[];
+  required: boolean;
+  deprecated: boolean;
+}
+interface RawTag {
+  name: string;
+  text: string;
+}
+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>;
+interface GeneratorOptions extends TypescriptConfig {
+  /**
+   * cache results, note that some options are not marked as dependency.
+   *
+   * @defaultValue false
+   */
+  cache?: Cache | false;
+  project?: Project;
+}
+declare function createGenerator(config?: GeneratorOptions | Project): {
+  generateDocumentation(file: {
+    path: string;
+    content?: string;
+  }, name: string | undefined, options?: GenerateOptions): Promise<GeneratedDoc[]>;
+  generateTypeTable(props: BaseTypeTableProps, options?: GenerateTypeTableOptions): Promise<GeneratedDoc[]>;
+};
+//#endregion
+export { GeneratorOptions as a, Cache as c, createProject as d, Generator as i, BaseTypeTableProps as l, GenerateOptions as n, RawTag as o, GeneratedDoc as r, createGenerator as s, DocEntry as t, GenerateTypeTableOptions as u };

package/dist/index.d.ts

@@ -1,36 +1,43 @@
-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';
-
-declare function renderTypeToHast(type: string): Promise<Nodes>;
-declare function renderMarkdownToHast(md: string): Promise<Nodes>;
+import { a as GeneratorOptions, c as Cache, d as createProject, i as Generator, l as BaseTypeTableProps, n as GenerateOptions, o as RawTag, r as GeneratedDoc, s as createGenerator, t as DocEntry, u as GenerateTypeTableOptions } from "./base-Dvhn4vZx.js";
+import { ResolvedShikiConfig } from "fumadocs-core/highlight/config";
+import { Nodes } from "hast";
+import { Root } from "mdast";
+import { Transformer } from "unified";
 
+//#region src/markdown.d.ts
+interface MarkdownRenderer {
+  renderTypeToHast: (type: string) => Nodes | Promise<Nodes>;
+  renderMarkdownToHast: (md: string) => Nodes | Promise<Nodes>;
+}
+//#endregion
+//#region src/lib/remark-auto-type-table.d.ts
 interface RemarkAutoTypeTableOptions {
-    /**
-     * @defaultValue 'auto-type-table'
-     */
-    name?: string;
-    /**
-     * @defaultValue 'TypeTable'
-     */
-    outputName?: string;
-    renderMarkdown?: typeof renderMarkdownToHast;
-    renderType?: typeof renderTypeToHast;
-    /**
-     * Customise type table generation
-     */
-    options?: GenerateTypeTableOptions;
-    /**
-     * generate required `value` property for `remark-stringify`
-     */
-    remarkStringify?: boolean;
-    generator?: Generator;
+  /**
+   * @defaultValue 'auto-type-table'
+   */
+  name?: string;
+  /**
+   * @defaultValue 'TypeTable'
+   */
+  outputName?: string;
+  /**
+   * config for Shiki when using default `renderMarkdown` & `renderType`.
+   */
+  shiki?: ResolvedShikiConfig;
+  renderMarkdown?: MarkdownRenderer['renderMarkdownToHast'];
+  renderType?: MarkdownRenderer['renderTypeToHast'];
+  /**
+   * Customise type table generation
+   */
+  options?: GenerateTypeTableOptions;
+  /**
+   * generate required `value` property for `remark-stringify`
+   */
+  remarkStringify?: boolean;
+  generator?: Generator;
 }
 interface TypeTableProps extends BaseTypeTableProps {
-    cwd?: true;
+  cwd?: true;
 }
 /**
  * Compile `auto-type-table` into Fumadocs UI compatible TypeTable
@@ -38,7 +45,8 @@ interface TypeTableProps extends BaseTypeTableProps {
  * MDX is required to use this plugin.
  */
 declare function remarkAutoTypeTable(config?: RemarkAutoTypeTableOptions): Transformer<Root, Root>;
-
+//#endregion
+//#region src/cache/fs-cache.d.ts
 declare function createFileSystemGeneratorCache(dir: string): Cache;
-
-export { Cache, Generator, type RemarkAutoTypeTableOptions, type TypeTableProps, createFileSystemGeneratorCache, remarkAutoTypeTable, renderMarkdownToHast };
+//#endregion
+export { Cache, DocEntry, GenerateOptions, GeneratedDoc, Generator, GeneratorOptions, type MarkdownRenderer, RawTag, RemarkAutoTypeTableOptions, TypeTableProps, createFileSystemGeneratorCache, createGenerator, createProject, remarkAutoTypeTable };