fumadocs-mdx 11.2.3 → 11.3.0

package/dist/{build-mdx-SZwWfZMp.d.ts → build-mdx-C2hor32E.d.cts}

@@ -24,7 +24,7 @@ interface GlobalConfig {
     /**
      * Configure global MDX options
      */
-    mdxOptions?: DefaultMDXOptions;
+    mdxOptions?: DefaultMDXOptions | (() => DefaultMDXOptions | Promise<DefaultMDXOptions>);
     /**
      * Fetch last modified time with specified version control
      * @defaultValue 'none'
@@ -34,6 +34,7 @@ interface GlobalConfig {
      * Generate manifest file on build mode
      *
      * @defaultValue false
+     * @deprecated No longer needed, use a route handler to export build time info
      */
     generateManifest?: boolean;
 }

package/dist/build-mdx-C2hor32E.d.ts

@@ -0,0 +1,106 @@
+import { AnyZodObject, z } from 'zod';
+import { MDXProps } from 'mdx/types';
+import { StructureOptions, RemarkHeadingOptions, RemarkImageOptions, RehypeCodeOptions, StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TableOfContents } from 'fumadocs-core/server';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Pluggable } from 'unified';
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkStructureOptions?: StructureOptions | false;
+    remarkHeadingOptions?: RemarkHeadingOptions;
+    remarkImageOptions?: RemarkImageOptions | false;
+    rehypeCodeOptions?: Partial<RehypeCodeOptions> | false;
+};
+declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
+
+interface GlobalConfig {
+    /**
+     * Configure global MDX options
+     */
+    mdxOptions?: DefaultMDXOptions | (() => DefaultMDXOptions | Promise<DefaultMDXOptions>);
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+    /**
+     * Generate manifest file on build mode
+     *
+     * @defaultValue false
+     * @deprecated No longer needed, use a route handler to export build time info
+     */
+    generateManifest?: boolean;
+}
+type InferSchema<CollectionOut> = CollectionOut extends {
+    _type: {
+        schema: infer T;
+    };
+} ? T : never;
+type InferSchemaType<C> = InferSchema<C> extends AnyZodObject ? z.output<InferSchema<C>> : never;
+interface FileInfo {
+    path: string;
+    absolutePath: string;
+}
+interface MarkdownProps {
+    body: (props: MDXProps) => React.ReactElement;
+    structuredData: StructuredData;
+    toc: TableOfContents;
+    _exports: Record<string, unknown>;
+    /**
+     * Only available when `lastModifiedTime` is enabled on MDX loader
+     */
+    lastModified?: Date;
+}
+type CollectionEntry<CollectionOut extends {
+    _type: {
+        runtime: unknown;
+    };
+}> = CollectionOut['_type']['runtime'];
+interface BaseCollectionEntry {
+    _file: FileInfo;
+}
+/**
+ * Get output type of collections
+ */
+type GetOutput<C extends {
+    _type: {
+        runtime: unknown;
+    };
+}> = CollectionEntry<C>[];
+
+interface MDXOptions extends ProcessorOptions {
+    /**
+     * Name of collection
+     */
+    collection?: string;
+    /**
+     * Specify a file path for source
+     */
+    filePath?: string;
+    frontmatter?: Record<string, unknown>;
+    /**
+     * Custom Vfile data
+     */
+    data?: Record<string, unknown>;
+    _compiler?: CompilerOptions;
+}
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+declare module 'vfile' {
+    interface DataMap {
+        /**
+         * The compiler object from loader
+         */
+        _compiler?: CompilerOptions;
+    }
+}
+
+export { type BaseCollectionEntry as B, type CollectionEntry as C, type DefaultMDXOptions as D, type FileInfo as F, type GlobalConfig as G, type InferSchema as I, type MarkdownProps as M, type MDXOptions as a, type InferSchemaType as b, type GetOutput as c, getDefaultMDXOptions as g };

package/dist/{chunk-UMDOD6VX.js → chunk-2ZPSMAUV.js}

@@ -1,7 +1,3 @@
-import {
-  getDefaultMDXOptions
-} from "./chunk-MKWJLEE7.js";
-
 // src/config/cached.ts
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
@@ -13,8 +9,8 @@ function findConfigFile() {
   return path.resolve("source.config.ts");
 }
 async function loadConfig(configPath) {
-  const outputPath = path.resolve(".source/source.config.mjs");
   const { build } = await import("esbuild");
+  const url = pathToFileURL(path.resolve(".source/source.config.mjs"));
   const transformed = await build({
     entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
@@ -27,16 +23,15 @@ async function loadConfig(configPath) {
     outExtension: {
       ".js": ".mjs"
     },
-    allowOverwrite: true,
-    splitting: true
+    allowOverwrite: true
   });
   if (transformed.errors.length > 0) {
     throw new Error("failed to compile configuration file");
   }
-  const url = pathToFileURL(outputPath);
+  const loaded = await import(`${url.href}?hash=${Date.now().toString()}`);
   const [err, config] = buildConfig(
     // every call to `loadConfig` will cause the previous cache to be ignored
-    await import(`${url.href}?hash=${Date.now().toString()}`)
+    loaded
   );
   if (err !== null) throw new Error(err);
   return config;
@@ -64,12 +59,23 @@ function buildConfig(config) {
       null
     ];
   }
+  let cachedMdxOptions;
   return [
     null,
     {
       global: globalConfig,
       collections,
-      defaultMdxOptions: getDefaultMDXOptions(globalConfig?.mdxOptions ?? {}),
+      async getDefaultMDXOptions() {
+        if (cachedMdxOptions) return cachedMdxOptions;
+        const { getDefaultMDXOptions } = await import("./mdx-options-L5C3NQRY.js");
+        const mdxOptions = globalConfig?.mdxOptions ?? {};
+        if (typeof mdxOptions === "function") {
+          cachedMdxOptions = getDefaultMDXOptions(await mdxOptions());
+        } else {
+          cachedMdxOptions = getDefaultMDXOptions(mdxOptions);
+        }
+        return cachedMdxOptions;
+      },
       _runtime: {
         files: /* @__PURE__ */ new Map()
       }
@@ -97,50 +103,9 @@ async function getConfigHash(configPath) {
   return hash.digest("hex");
 }
 
-// src/map/manifest.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-
-// src/utils/get-type-from-path.ts
-import { extname } from "node:path";
-var docTypes = [".mdx", ".md"];
-var metaTypes = [".json", ".yaml"];
-function getTypeFromPath(path3) {
-  const ext = extname(path3);
-  if (docTypes.includes(ext)) return "doc";
-  if (metaTypes.includes(ext)) return "meta";
-}
-
-// src/map/manifest.ts
-function getManifestEntryPath(originalPath) {
-  const toName = path2.relative(process.cwd(), originalPath).replaceAll(`..${path2.sep}`, "-").replaceAll(path2.sep, "_");
-  return path2.resolve(".next/cache/fumadocs", `${toName}.json`);
-}
-function writeManifest(to, config) {
-  const output = { files: [] };
-  for (const [file, collection] of config._runtime.files.entries()) {
-    const type = config.collections.get(collection)?.type ?? getTypeFromPath(file);
-    if (type === "meta") continue;
-    try {
-      const content = fs2.readFileSync(getManifestEntryPath(file));
-      const meta = JSON.parse(content.toString());
-      output.files.push({
-        ...meta,
-        collection
-      });
-    } catch (e) {
-      console.error(`cannot find the search index of ${file}`, e);
-    }
-  }
-  fs2.writeFileSync(to, JSON.stringify(output));
-}
-
 export {
   findConfigFile,
   loadConfig,
   loadConfigCached,
-  getConfigHash,
-  getTypeFromPath,
-  getManifestEntryPath,
-  writeManifest
+  getConfigHash
 };

package/dist/config/index.cjs

@@ -0,0 +1,244 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  defineCollections: () => defineCollections,
+  defineConfig: () => defineConfig,
+  defineDocs: () => defineDocs,
+  frontmatterSchema: () => frontmatterSchema,
+  getDefaultMDXOptions: () => getDefaultMDXOptions,
+  metaSchema: () => metaSchema,
+  remarkInclude: () => remarkInclude
+});
+module.exports = __toCommonJS(config_exports);
+
+// src/utils/schema.ts
+var import_zod = require("zod");
+var metaSchema = import_zod.z.object({
+  title: import_zod.z.string().optional(),
+  pages: import_zod.z.array(import_zod.z.string()).optional(),
+  description: import_zod.z.string().optional(),
+  root: import_zod.z.boolean().optional(),
+  defaultOpen: import_zod.z.boolean().optional(),
+  icon: import_zod.z.string().optional()
+});
+var frontmatterSchema = import_zod.z.object({
+  title: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  icon: import_zod.z.string().optional(),
+  full: import_zod.z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: import_zod.z.object({}).passthrough().optional()
+});
+
+// src/config/define.ts
+function defineCollections(options) {
+  return {
+    _doc: "collections",
+    // @ts-expect-error -- internal type inferring
+    _type: void 0,
+    ...options
+  };
+}
+function defineDocs(options) {
+  const dir = options?.dir ?? "content/docs";
+  return {
+    docs: defineCollections({
+      type: "doc",
+      dir,
+      schema: frontmatterSchema,
+      ...options?.docs
+    }),
+    meta: defineCollections({
+      type: "meta",
+      dir,
+      schema: metaSchema,
+      ...options?.meta
+    })
+  };
+}
+function defineConfig(config = {}) {
+  return config;
+}
+
+// src/utils/mdx-options.ts
+var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+
+// src/mdx-plugins/remark-exports.ts
+var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: (0, import_estree_util_value_to_estree.valueToEstree)(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/utils/mdx-options.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      import_mdx_plugins.remarkGfm,
+      [
+        import_mdx_plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [import_mdx_plugins.remarkImage, remarkImageOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        import_mdx_plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [import_mdx_plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      [import_mdx_plugins.rehypeToc]
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+
+// src/mdx-plugins/remark-include.ts
+var import_unist_util_visit = require("unist-util-visit");
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs/promises"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function remarkInclude() {
+  return async (tree, file) => {
+    const queue = [];
+    (0, import_unist_util_visit.visit)(tree, ["mdxJsxFlowElement", "paragraph"], (node) => {
+      let specifier;
+      if (node.type === "paragraph" && node.children.length === 3) {
+        const [open, content, closure] = node.children;
+        if (open.type === "html" && open.value === "<include>" && content.type === "text" && closure.type === "html" && closure.value === "</include>") {
+          specifier = content.value.trim();
+        }
+      }
+      if (node.type === "mdxJsxFlowElement" && node.name === "include") {
+        const child = node.children.at(0);
+        if (!child || child.type !== "text") return;
+        specifier = child.value;
+      }
+      if (!specifier) return "skip";
+      const targetPath = path.resolve(path.dirname(file.path), specifier);
+      queue.push(
+        fs.readFile(targetPath).then((content) => {
+          const parsed = this.parse((0, import_gray_matter.default)(content).content);
+          if (file.data._compiler) {
+            file.data._compiler.addDependency(targetPath);
+          }
+          Object.assign(node, parsed);
+        })
+      );
+      return "skip";
+    });
+    await Promise.all(queue);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineCollections,
+  defineConfig,
+  defineDocs,
+  frontmatterSchema,
+  getDefaultMDXOptions,
+  metaSchema,
+  remarkInclude
+});

package/dist/config/index.d.cts

@@ -0,0 +1,134 @@
+import { F as FileInfo, G as GlobalConfig, M as MarkdownProps, a as MDXOptions, B as BaseCollectionEntry } from '../build-mdx-C2hor32E.cjs';
+export { C as CollectionEntry, D as DefaultMDXOptions, c as GetOutput, I as InferSchema, b as InferSchemaType, g as getDefaultMDXOptions } from '../build-mdx-C2hor32E.cjs';
+import { z, ZodTypeAny } from 'zod';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Processor, Transformer } from 'unified';
+import { Root } from 'mdast';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodBoolean>;
+    defaultOpen: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    root?: boolean | undefined;
+    title?: string | undefined;
+    icon?: string | undefined;
+    pages?: string[] | undefined;
+    description?: string | undefined;
+    defaultOpen?: boolean | undefined;
+}, {
+    root?: boolean | undefined;
+    title?: string | undefined;
+    icon?: string | undefined;
+    pages?: string[] | undefined;
+    description?: string | undefined;
+    defaultOpen?: boolean | undefined;
+}>;
+declare const frontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    _openapi: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    icon?: string | undefined;
+    description?: string | undefined;
+    full?: boolean | undefined;
+    _openapi?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    title: string;
+    icon?: string | undefined;
+    description?: string | undefined;
+    full?: boolean | undefined;
+    _openapi?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+
+interface TransformContext {
+    path: string;
+    source: string;
+    /**
+     * Compile MDX to JavaScript
+     */
+    buildMDX: (source: string, options?: ProcessorOptions) => Promise<string>;
+}
+interface BaseCollection<Schema> {
+    /**
+     * Directories to scan
+     */
+    dir: string | string[];
+    /**
+     * what files to include/exclude (glob patterns)
+     *
+     * Include all files if not specified
+     */
+    files?: string[];
+    schema?: Schema | ((ctx: TransformContext) => Schema);
+}
+interface MetaCollection<Schema extends ZodTypeAny = ZodTypeAny, TransformOutput = unknown> extends BaseCollection<Schema> {
+    type: 'meta';
+    /**
+     * Do transformation in runtime.
+     *
+     * This cannot be optimized by bundlers/loaders, avoid expensive calculations here.
+     */
+    transform?: (entry: {
+        data: z.output<Schema>;
+        file: FileInfo;
+    }, globalConfig?: GlobalConfig) => TransformOutput | Promise<TransformOutput>;
+}
+interface DocCollection<Schema extends ZodTypeAny = ZodTypeAny, Async extends boolean = boolean, TransformOutput = unknown> extends BaseCollection<Schema> {
+    type: 'doc';
+    /**
+     * Do transformation in runtime.
+     *
+     * This cannot be optimized by bundlers/loaders, avoid expensive calculations here.
+     */
+    transform?: (entry: {
+        data: z.output<Schema>;
+        file: FileInfo;
+        mdx: Async extends true ? MarkdownProps : never;
+    }, globalConfig?: GlobalConfig) => TransformOutput | Promise<TransformOutput>;
+    mdxOptions?: MDXOptions;
+    /**
+     * Load files with async
+     */
+    async?: Async;
+}
+declare function defineCollections<T extends 'doc' | 'meta', Schema extends ZodTypeAny = ZodTypeAny, Async extends boolean = false, TransformOutput = unknown>(options: {
+    type: T;
+} & (T extends 'doc' ? DocCollection<Schema, Async, TransformOutput> : MetaCollection<Schema, TransformOutput>)): {
+    _doc: 'collections';
+    type: T;
+    _type: {
+        async: Async;
+        transform: TransformOutput;
+        runtime: T extends 'doc' ? Async extends true ? z.infer<Schema> & BaseCollectionEntry & {
+            load: () => Promise<MarkdownProps>;
+        } : Omit<MarkdownProps, keyof z.infer<Schema>> & z.infer<Schema> & BaseCollectionEntry : typeof options extends MetaCollection ? z.infer<Schema> & BaseCollectionEntry : never;
+    };
+};
+declare function defineDocs<DocData extends ZodTypeAny = typeof frontmatterSchema, MetaData extends ZodTypeAny = typeof metaSchema, DocAsync extends boolean = false, DocOut = unknown, MetaOut = unknown>(options?: {
+    /**
+     * The directory to scan files
+     *
+     *  @defaultValue 'content/docs'
+     */
+    dir?: string | string[];
+    docs?: Partial<DocCollection<DocData, DocAsync, DocOut>>;
+    meta?: Partial<MetaCollection<MetaData, MetaOut>>;
+}): {
+    docs: ReturnType<typeof defineCollections<'doc', DocData, DocAsync, DocOut>>;
+    meta: ReturnType<typeof defineCollections<'meta', MetaData, false, MetaOut>>;
+};
+declare function defineConfig(config?: GlobalConfig): GlobalConfig;
+
+declare function remarkInclude(this: Processor): Transformer<Root, Root>;
+
+export { type BaseCollection, BaseCollectionEntry, type DocCollection, FileInfo, GlobalConfig, MarkdownProps, type MetaCollection, type TransformContext, defineCollections, defineConfig, defineDocs, frontmatterSchema, metaSchema, remarkInclude };

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FileInfo, G as GlobalConfig, M as MarkdownProps, a as MDXOptions, B as BaseCollectionEntry } from '../build-mdx-SZwWfZMp.js';
-export { C as CollectionEntry, D as DefaultMDXOptions, c as GetOutput, I as InferSchema, b as InferSchemaType, g as getDefaultMDXOptions } from '../build-mdx-SZwWfZMp.js';
+import { F as FileInfo, G as GlobalConfig, M as MarkdownProps, a as MDXOptions, B as BaseCollectionEntry } from '../build-mdx-C2hor32E.js';
+export { C as CollectionEntry, D as DefaultMDXOptions, c as GetOutput, I as InferSchema, b as InferSchemaType, g as getDefaultMDXOptions } from '../build-mdx-C2hor32E.js';
 import { z, ZodTypeAny } from 'zod';
 import { ProcessorOptions } from '@mdx-js/mdx';
 import { Processor, Transformer } from 'unified';

package/dist/config/index.js

@@ -3,7 +3,7 @@ import {
 } from "../chunk-GUHWD47S.js";
 import {
   getDefaultMDXOptions
-} from "../chunk-MKWJLEE7.js";
+} from "../chunk-6LEQ23AC.js";
 
 // src/utils/schema.ts
 import { z } from "zod";