fumadocs-mdx 14.0.0 → 14.0.2

package/dist/chunk-WBIHDYMN.js

@@ -0,0 +1,126 @@
+// src/utils/codegen.ts
+import path from "path";
+import { glob } from "tinyglobby";
+function createCodegen({
+  target = "default",
+  outDir = "",
+  jsExtension = false,
+  globCache = /* @__PURE__ */ new Map()
+}) {
+  let eagerImportId = 0;
+  const banner = ["// @ts-nocheck"];
+  if (target === "vite") {
+    banner.push('/// <reference types="vite/client" />');
+  }
+  return {
+    options: {
+      target,
+      outDir
+    },
+    lines: [],
+    addImport(statement) {
+      this.lines.unshift(statement);
+    },
+    async pushAsync(insert) {
+      for (const line of await Promise.all(insert)) {
+        if (line === void 0) continue;
+        this.lines.push(line);
+      }
+    },
+    async generateGlobImport(patterns, options) {
+      if (target === "vite") {
+        return this.generateViteGlobImport(patterns, options);
+      }
+      return this.generateNodeGlobImport(patterns, options);
+    },
+    generateViteGlobImport(patterns, { base, ...rest }) {
+      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+        normalizeViteGlobPath
+      );
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          base: normalizeViteGlobPath(path.relative(outDir, base)),
+          ...rest
+        },
+        null,
+        2
+      )})`;
+    },
+    async generateNodeGlobImport(patterns, {
+      base,
+      eager = false,
+      query = {},
+      import: importName
+    }) {
+      const cacheKey = JSON.stringify({ patterns, base });
+      let files = globCache.get(cacheKey);
+      if (!files) {
+        files = glob(patterns, {
+          cwd: base
+        });
+        globCache.set(cacheKey, files);
+      }
+      let code = "{";
+      for (const item of await files) {
+        const fullPath = path.join(base, item);
+        const searchParams = new URLSearchParams();
+        for (const [k, v] of Object.entries(query)) {
+          searchParams.set(k, v);
+        }
+        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
+        if (eager) {
+          const name = `__fd_glob_${eagerImportId++}`;
+          this.lines.unshift(
+            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+          );
+          code += `${JSON.stringify(item)}: ${name}, `;
+        } else {
+          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+          if (importName) {
+            line += `.then(mod => mod.${importName})`;
+          }
+          code += `${line}, `;
+        }
+      }
+      code += "}";
+      return code;
+    },
+    formatImportPath(file) {
+      const ext = path.extname(file);
+      let filename;
+      if (ext === ".ts" && jsExtension) {
+        filename = file.substring(0, file.length - ext.length) + ".js";
+      } else if (ext === ".ts") {
+        filename = file.substring(0, file.length - ext.length);
+      } else {
+        filename = file;
+      }
+      const importPath = slash(path.relative(outDir, filename));
+      return importPath.startsWith(".") ? importPath : `./${importPath}`;
+    },
+    toString() {
+      return [...banner, ...this.lines].join("\n");
+    }
+  };
+}
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function slash(path2) {
+  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path2;
+  }
+  return path2.replaceAll("\\", "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+export {
+  createCodegen,
+  ident
+};

package/dist/config/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, f as DefaultMDXOptions, D as DocCollection, b as DocsCollection, G as GlobalConfig, g as MDXPresetOptions, M as MetaCollection, P as PostprocessOptions, h as applyMdxPreset, d as defineCollections, e as defineConfig, c as defineDocs, i as frontmatterSchema, m as metaSchema } from '../index-D7JdSMpp.js';
+export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, f as DefaultMDXOptions, D as DocCollection, b as DocsCollection, G as GlobalConfig, g as MDXPresetOptions, M as MetaCollection, P as PostprocessOptions, h as applyMdxPreset, d as defineCollections, e as defineConfig, c as defineDocs, i as frontmatterSchema, m as metaSchema } from '../core-C3QZSdEx.js';
 import { Processor, Transformer } from 'unified';
 import { Root } from 'mdast';
 import '@mdx-js/mdx';
@@ -7,6 +7,11 @@ import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
 import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.js';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdx/types';
 
 declare function remarkInclude(this: Processor): Transformer<Root, Root>;
 

package/dist/config/index.js

@@ -3,7 +3,7 @@ import {
 } from "../chunk-FBLMK4RS.js";
 import {
   applyMdxPreset
-} from "../chunk-E5DJTSIM.js";
+} from "../chunk-S7KOJHHO.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/config/zod-4.ts

package/dist/{index-D7JdSMpp.d.cts → core-C3QZSdEx.d.ts}

@@ -5,6 +5,8 @@ import * as Plugins from 'fumadocs-core/mdx-plugins';
 import { z } from 'zod';
 import { FSWatcher } from 'chokidar';
 import { VFile } from 'vfile';
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { InternalTypeConfig, DocData, DocMethods, MetaMethods } from './runtime/types.js';
 
 type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
 type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
@@ -174,6 +176,71 @@ interface DocsCollectionItem extends DocsCollection {
     hasFile: (filePath: string) => boolean;
 }
 
+type MetaCollectionEntry<Data> = Data & MetaMethods;
+type DocCollectionEntry<Name extends string = string, Frontmatter = unknown, TC extends InternalTypeConfig = InternalTypeConfig> = DocData & DocMethods & Frontmatter & TC['DocData'][Name];
+type AsyncDocCollectionEntry<Name extends string = string, Frontmatter = unknown, TC extends InternalTypeConfig = InternalTypeConfig> = {
+    load: () => Promise<DocData & TC['DocData'][Name]>;
+} & DocMethods & Frontmatter;
+interface DocsCollectionEntry<Name extends string = string, Frontmatter extends PageData = PageData, Meta extends MetaData = MetaData, TC extends InternalTypeConfig = InternalTypeConfig> {
+    docs: DocCollectionEntry<Name, Frontmatter, TC>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: DocCollectionEntry<Name, Frontmatter, TC>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+interface AsyncDocsCollectionEntry<Name extends string = string, Frontmatter extends PageData = PageData, Meta extends MetaData = MetaData, TC extends InternalTypeConfig = InternalTypeConfig> {
+    docs: AsyncDocCollectionEntry<Name, Frontmatter, TC>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: AsyncDocCollectionEntry<Name, Frontmatter, TC>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+type AwaitableGlobEntries<T> = Record<string, T | (() => Promise<T>)>;
+type ServerCreate<Config, TC extends InternalTypeConfig = InternalTypeConfig> = ReturnType<typeof server<Config, TC>>;
+interface ServerOptions {
+    doc?: {
+        passthroughs?: string[];
+    };
+}
+declare function server<Config, TC extends InternalTypeConfig>(options?: ServerOptions): {
+    doc<Name extends keyof Config & string>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? DocCollectionEntry<Name, StandardSchemaV1.InferOutput<Schema>, TC>[] : never>;
+    docLazy<Name extends keyof Config & string>(_name: Name, base: string, head: AwaitableGlobEntries<unknown>, body: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<Name, StandardSchemaV1.InferOutput<Schema>, TC>[] : never>;
+    meta<Name extends keyof Config & string>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends MetaCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<StandardSchemaV1<unknown, unknown>, infer Schema extends StandardSchemaV1<unknown, unknown>> ? MetaCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docs<Name extends keyof Config & string>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docGlob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? DocsCollectionEntry<Name, StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>, TC> : never : never : never>;
+    docsLazy<Name extends keyof Config & string>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docHeadGlob: AwaitableGlobEntries<unknown>, docBodyGlob: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? AsyncDocsCollectionEntry<Name, StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>, TC> : never : never : never>;
+};
+declare function toFumadocsSource<Page extends DocMethods & PageData, Meta extends MetaMethods & MetaData>(pages: Page[], metas: Meta[]): Source<{
+    pageData: Page;
+    metaData: Meta;
+}>;
+
+interface IndexFilePluginOptions {
+    target?: 'default' | 'vite';
+    /**
+     * add `.js` extensions to imports, needed for ESM without bundler resolution
+     */
+    addJsExtension?: boolean;
+    /**
+     * Generate entry point for browser
+     * @defaultValue true
+     */
+    browser?: boolean;
+    /**
+     * Generate entry point for dynamic compilation
+     * @defaultValue true
+     */
+    dynamic?: boolean;
+}
+interface IndexFilePlugin {
+    ['index-file']?: {
+        generateTypeConfig?: (this: PluginContext) => string | void;
+        serverOptions?: (this: PluginContext, options: ServerOptions) => void;
+    };
+}
+declare function indexFile(options?: IndexFilePluginOptions): Plugin;
+
 type Awaitable<T> = T | Promise<T>;
 interface EmitEntry {
     /**
@@ -191,7 +258,7 @@ interface TransformOptions<Collection> {
     filePath: string;
     source: string;
 }
-interface Plugin {
+interface Plugin extends IndexFilePlugin {
     name?: string;
     /**
      * on config loaded/updated
@@ -247,19 +314,21 @@ declare const _Defaults: {
     outDir: string;
 };
 declare function createCore(options: CoreOptions, defaultPlugins?: PluginOption[]): {
-    _options: CoreOptions;
     /**
      * Convenient cache store, reset when config changes
      */
     cache: Map<string, unknown>;
     init({ config: newConfig }: {
         config: Awaitable<LoadedConfig>;
-    }): Promise</*elided*/ any>;
+    }): Promise<void>;
+    getOptions(): CoreOptions;
     getConfig(): LoadedConfig;
     /**
      * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
      */
     getCompiledConfigPath(): string;
+    getPlugins(): Plugin[];
+    getPluginContext(): PluginContext;
     initServer(server: ServerContext): Promise<void>;
     emit({ filterPlugin }?: EmitOptions): Promise<EmitEntry[]>;
     emitAndWrite(emitOptions?: EmitOptions): Promise<void>;
@@ -269,4 +338,4 @@ declare function createCore(options: CoreOptions, defaultPlugins?: PluginOption[
 };
 type Core = ReturnType<typeof createCore>;
 
-export { type AnyCollection as A, type BaseCollection as B, type CoreOptions as C, type DocCollection as D, type ExtractedReference as E, type GlobalConfig as G, type MetaCollection as M, type PostprocessOptions as P, type ServerContext as S, type TransformOptions as T, _Defaults as _, type CollectionSchema as a, type DocsCollection as b, defineDocs as c, defineCollections as d, defineConfig as e, type DefaultMDXOptions as f, type MDXPresetOptions as g, applyMdxPreset as h, frontmatterSchema as i, type Plugin as j, type EmitEntry as k, type PluginContext as l, metaSchema as m, type CompilationContext as n, type PluginOption as o, type EmitOptions as p, createCore as q, type Core as r };
+export { type AnyCollection as A, type BaseCollection as B, type CoreOptions as C, type DocCollection as D, type ExtractedReference as E, toFumadocsSource as F, type GlobalConfig as G, indexFile as H, type IndexFilePluginOptions as I, type IndexFilePlugin as J, type MetaCollection as M, type PostprocessOptions as P, type ServerOptions as S, type TransformOptions as T, _Defaults as _, type CollectionSchema as a, type DocsCollection as b, defineDocs as c, defineCollections as d, defineConfig as e, type DefaultMDXOptions as f, type MDXPresetOptions as g, applyMdxPreset as h, frontmatterSchema as i, type Plugin as j, type AsyncDocCollectionEntry as k, type AsyncDocsCollectionEntry as l, metaSchema as m, type EmitEntry as n, type PluginContext as o, type CompilationContext as p, type PluginOption as q, type ServerContext as r, type EmitOptions as s, createCore as t, type Core as u, type MetaCollectionEntry as v, type DocCollectionEntry as w, type DocsCollectionEntry as x, type ServerCreate as y, server as z };

package/dist/{index-BlVBvy-z.d.ts → index-RVIZxMZG.d.ts}

@@ -1,4 +1,4 @@
-import { C as CoreOptions } from './index-D7JdSMpp.js';
+import { C as CoreOptions } from './core-C3QZSdEx.js';
 
 interface WebpackLoaderOptions extends CoreOptions {
     compiledConfigPath: string;

package/dist/index.d.ts

@@ -1,8 +1,61 @@
-export { n as CompilationContext, r as Core, C as CoreOptions, k as EmitEntry, p as EmitOptions, E as ExtractedReference, j as Plugin, l as PluginContext, o as PluginOption, S as ServerContext, T as TransformOptions, _ as _Defaults, q as createCore } from './index-D7JdSMpp.js';
-import '@mdx-js/mdx';
+export { p as CompilationContext, u as Core, C as CoreOptions, n as EmitEntry, s as EmitOptions, E as ExtractedReference, j as Plugin, o as PluginContext, q as PluginOption, r as ServerContext, T as TransformOptions, _ as _Defaults, t as createCore } from './core-C3QZSdEx.js';
+import { createProcessor } from '@mdx-js/mdx';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { FC } from 'react';
+import { MDXProps } from 'mdx/types';
 import '@standard-schema/spec';
 import 'unified';
-import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
 import 'vfile';
+import 'fumadocs-core/source';
+import './runtime/types.js';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'mdast';
+
+type Processor = ReturnType<typeof createProcessor>;
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+interface CompiledMDXProperties<Frontmatter = Record<string, unknown>> {
+    frontmatter: Frontmatter;
+    structuredData: StructuredData;
+    toc: TOCItemType[];
+    default: FC<MDXProps>;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _markdown?: string;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _mdast?: string;
+}
+interface FumadocsDataMap {
+    /**
+     * [Fumadocs MDX] raw frontmatter, you can modify it
+     */
+    frontmatter?: Record<string, unknown>;
+    /**
+     * [Fumadocs MDX] additional ESM exports to write
+     */
+    'mdx-export'?: {
+        name: string;
+        value: unknown;
+    }[];
+    /**
+     * [Fumadocs MDX] The compiler object from loader
+     */
+    _compiler?: CompilerOptions;
+    /**
+     * [Fumadocs MDX] get internal processor, do not use this on user land.
+     */
+    _getProcessor?: (format: 'md' | 'mdx') => Processor;
+}
+declare module 'vfile' {
+    interface DataMap extends FumadocsDataMap {
+    }
+}
+
+export type { CompiledMDXProperties };

package/dist/load-from-file-OZ5N7DXU.js

@@ -0,0 +1,8 @@
+import {
+  loadConfig
+} from "./chunk-LPX7ZO66.js";
+import "./chunk-6RPNS75C.js";
+import "./chunk-S7KOJHHO.js";
+export {
+  loadConfig
+};