fumadocs-mdx 13.0.8 → 14.0.1

package/dist/chunk-BEBCWQC7.js

@@ -0,0 +1,224 @@
+import {
+  ident
+} from "./chunk-WBIHDYMN.js";
+
+// src/utils/validation.ts
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+    this.title = message;
+    this.issues = issues;
+  }
+  async toStringFormatted() {
+    const picocolors = await import("picocolors");
+    return [
+      picocolors.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => picocolors.redBright(
+          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        )
+      )
+    ].join("\n");
+  }
+};
+async function validate(schema, data, context, errorMessage) {
+  if (typeof schema === "function" && !("~standard" in schema)) {
+    schema = schema(context);
+  }
+  if ("~standard" in schema) {
+    const result = await schema["~standard"].validate(
+      data
+    );
+    if (result.issues) {
+      throw new ValidationError(errorMessage, result.issues);
+    }
+    return result.value;
+  }
+  return data;
+}
+
+// src/core.ts
+import path from "path";
+import fs from "fs/promises";
+var _Defaults = {
+  configPath: "source.config.ts",
+  outDir: ".source"
+};
+async function getPlugins(pluginOptions) {
+  const plugins = [];
+  for await (const option of pluginOptions) {
+    if (!option) continue;
+    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
+    else plugins.push(option);
+  }
+  return plugins;
+}
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins;
+  async function transformMetadata({
+    collection,
+    filePath,
+    source
+  }, data) {
+    if (collection.schema) {
+      data = await validate(
+        collection.schema,
+        data,
+        { path: filePath, source },
+        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
+      );
+    }
+    return data;
+  }
+  const core = {
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: /* @__PURE__ */ new Map(),
+    async init({ config: newConfig }) {
+      config = await newConfig;
+      this.cache.clear();
+      plugins = await getPlugins([
+        postprocessPlugin(),
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]);
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(pluginContext, config);
+        if (out) config = out;
+      }
+    },
+    getOptions() {
+      return options;
+    },
+    getConfig() {
+      return config;
+    },
+    /**
+     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+     */
+    getCompiledConfigPath() {
+      return path.join(options.outDir, "source.config.mjs");
+    },
+    getPlugins() {
+      return plugins;
+    },
+    getPluginContext() {
+      return pluginContext;
+    },
+    async initServer(server) {
+      for (const plugin of plugins) {
+        await plugin.configureServer?.call(pluginContext, server);
+      }
+    },
+    async emit({ filterPlugin = () => true } = {}) {
+      return (await Promise.all(
+        plugins.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(pluginContext);
+        })
+      )).flat();
+    },
+    async emitAndWrite(emitOptions) {
+      const start = performance.now();
+      const out = await this.emit(emitOptions);
+      await Promise.all(
+        out.map(async (entry) => {
+          const file = path.join(options.outDir, entry.path);
+          await fs.mkdir(path.dirname(file), { recursive: true });
+          await fs.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    },
+    async transformMeta(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.meta?.transform)
+          data = await plugin.meta.transform.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformFrontmatter(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.doc?.frontmatter)
+          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformVFile(options2, file) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      for (const plugin of plugins) {
+        if (plugin.doc?.vfile)
+          file = await plugin.doc.vfile.call(ctx, file) ?? file;
+      }
+      return file;
+    }
+  };
+  const pluginContext = {
+    core,
+    ...options
+  };
+  return core;
+}
+function postprocessPlugin() {
+  const LinkReferenceTypes = `{
+  /**
+   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+   */
+  extractedReferences?: import('fumadocs-mdx').ExtractedReference[];
+}`;
+  return {
+    "index-file": {
+      generateTypeConfig() {
+        const lines = [];
+        lines.push("{");
+        lines.push("  DocData: {");
+        for (const collection of this.core.getConfig().collectionList) {
+          let postprocessOptions;
+          switch (collection.type) {
+            case "doc":
+              postprocessOptions = collection.postprocess;
+              break;
+            case "docs":
+              postprocessOptions = collection.docs.postprocess;
+              break;
+          }
+          if (postprocessOptions?.extractLinkReferences) {
+            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
+          }
+        }
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      },
+      serverOptions(options) {
+        options.doc ??= {};
+        options.doc.passthroughs ??= [];
+        options.doc.passthroughs.push("extractedReferences");
+      }
+    }
+  };
+}
+
+export {
+  ValidationError,
+  _Defaults,
+  createCore
+};

package/dist/chunk-E5DJTSIM.js

@@ -0,0 +1,86 @@
+// src/config/preset.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function applyMdxPreset(options = {}) {
+  return async (environment = "bundler") => {
+    if (options.preset === "minimal") return options;
+    const plugins = await import("fumadocs-core/mdx-plugins");
+    const {
+      valueToExport = [],
+      rehypeCodeOptions,
+      remarkImageOptions,
+      remarkHeadingOptions,
+      remarkStructureOptions,
+      remarkCodeTabOptions,
+      remarkNpmOptions,
+      ...mdxOptions
+    } = options;
+    const remarkPlugins = pluginOption(
+      (v) => [
+        plugins.remarkGfm,
+        [
+          plugins.remarkHeading,
+          {
+            generateToc: false,
+            ...remarkHeadingOptions
+          }
+        ],
+        remarkImageOptions !== false && [
+          plugins.remarkImage,
+          {
+            ...remarkImageOptions,
+            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
+          }
+        ],
+        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+          plugins.remarkCodeTab,
+          remarkCodeTabOptions
+        ],
+        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+        ...v,
+        remarkStructureOptions !== false && [
+          plugins.remarkStructure,
+          remarkStructureOptions
+        ],
+        valueToExport.length > 0 && (() => {
+          return (_, file) => {
+            file.data["mdx-export"] ??= [];
+            for (const name of valueToExport) {
+              if (!(name in file.data)) continue;
+              file.data["mdx-export"].push({
+                name,
+                value: file.data[name]
+              });
+            }
+          };
+        })
+      ],
+      mdxOptions.remarkPlugins
+    );
+    const rehypePlugins = pluginOption(
+      (v) => [
+        rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+        ...v,
+        plugins.rehypeToc
+      ],
+      mdxOptions.rehypePlugins
+    );
+    return {
+      ...mdxOptions,
+      outputFormat: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
+  };
+}
+
+export {
+  applyMdxPreset
+};

package/dist/{chunk-K5ZLPEIQ.js → chunk-FBLMK4RS.js}

@@ -53,6 +53,14 @@ function remarkMarkAndUnravel() {
   };
 }
 
+// src/loaders/mdx/mdast-utils.ts
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+
 // src/loaders/mdx/remark-include.ts
 var ElementLikeTypes = [
   "mdxJsxFlowElement",
@@ -76,12 +84,6 @@ function parseElementAttributes(element) {
   }
   return element.attributes ?? {};
 }
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 function parseSpecifier(specifier) {
   const idx = specifier.lastIndexOf("#");
   if (idx === -1) return { file: specifier };
@@ -203,5 +205,6 @@ ${e instanceof Error ? e.message : String(e)}`,
 }
 
 export {
+  flattenNode,
   remarkInclude
 };

package/dist/chunk-IQGEFL2B.js

@@ -0,0 +1,17 @@
+import {
+  createCore
+} from "./chunk-BEBCWQC7.js";
+
+// src/webpack/index.ts
+var core;
+function getCore(options) {
+  return core ??= createCore({
+    environment: "webpack",
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
+}
+
+export {
+  getCore
+};

package/dist/{chunk-5FTSWCB4.js → chunk-K6HCOGOX.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-2AQRQXSO.js";
+} from "./chunk-BEBCWQC7.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";
@@ -83,7 +83,7 @@ function toWebpack(loader) {
       }
     } catch (error) {
       if (error instanceof ValidationError) {
-        return callback(new Error(error.toStringFormatted()));
+        return callback(new Error(await error.toStringFormatted()));
       }
       if (!(error instanceof Error)) throw error;
       const fpath = path.relative(this.context, this.resourcePath);
@@ -115,8 +115,8 @@ function toBun(loader) {
           }
         }
       };
-      if (loader.bun?.loadSync) {
-        return loader.bun.loadSync(readFileSync(filePath).toString(), input);
+      if (loader.bun?.load) {
+        return loader.bun.load(readFileSync(filePath).toString(), input);
       }
       const result = loader.load(input);
       if (result instanceof Promise) {
@@ -137,23 +137,20 @@ function createStandaloneConfigLoader({
   let loaded;
   async function getConfigHash() {
     if (mode === "production") return "static";
-    const stats = await fs2.stat(core._options.configPath).catch(() => {
+    const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
       throw new Error("Cannot find config file");
     });
     return stats.mtime.getTime().toString();
   }
   async function newConfig() {
-    const { loadConfig } = await import("./load-from-file-AVYOFOI7.js");
+    const { loadConfig } = await import("./load-from-file-5HUQN36V.js");
     await core.init({
-      config: loadConfig(
-        core._options.configPath,
-        core._options.outDir,
-        buildConfig
-      )
+      config: loadConfig(core, buildConfig)
     });
     return core.getConfig();
   }
   return {
+    core,
     async getConfig() {
       const hash = await getConfigHash();
       if (loaded && loaded.hash === hash) return loaded.config;
@@ -167,6 +164,7 @@ function createStandaloneConfigLoader({
 }
 function createIntegratedConfigLoader(core) {
   return {
+    core,
     getConfig() {
       return core.getConfig();
     }

package/dist/{chunk-QXHN25N3.js → chunk-MTTISKQJ.js}

@@ -1,12 +1,12 @@
 import {
   buildConfig
-} from "./chunk-2HXTGJBI.js";
+} from "./chunk-ZY6UZ7NH.js";
 
 // src/config/load-from-file.ts
-import * as path from "path";
 import { pathToFileURL } from "url";
-async function compileConfig(configPath, outDir) {
+async function compileConfig(core) {
   const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
   const transformed = await build({
     entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
@@ -25,9 +25,9 @@ async function compileConfig(configPath, outDir) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, outDir, build = false) {
-  if (build) await compileConfig(configPath, outDir);
-  const url = pathToFileURL(path.resolve(outDir, "source.config.mjs"));
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = pathToFileURL(core.getCompiledConfigPath());
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)

package/dist/{chunk-3J3WL7WN.js → chunk-SLY7WXTX.js}

@@ -1,9 +1,11 @@
 import {
+  flattenNode,
   remarkInclude
-} from "./chunk-K5ZLPEIQ.js";
+} from "./chunk-FBLMK4RS.js";
 
 // src/loaders/mdx/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";
+import { VFile } from "vfile";
 
 // src/loaders/mdx/remark-postprocess.ts
 import { visit } from "unist-util-visit";
@@ -15,48 +17,66 @@ function remarkPostprocess({
   _format,
   includeProcessedMarkdown = false,
   includeMDAST = false,
+  extractLinkReferences = false,
   valueToExport = []
 }) {
   let _stringifyProcessor;
   const getStringifyProcessor = () => {
-    if (_format === "mdx") return this;
-    return _stringifyProcessor ??= this().use(remarkMdx).freeze();
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(remarkMdx).freeze()
+    );
   };
   return (tree, file) => {
-    let title;
-    const urls = [];
-    visit(tree, ["heading", "link"], (node) => {
-      if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode(node);
-      }
-      if (node.type !== "link") return;
-      urls.push({
-        href: node.url
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      visit(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    if (extractLinkReferences) {
+      const urls = [];
+      visit(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
       });
-      return "skip";
-    });
-    if (title) {
-      file.data.frontmatter ??= {};
-      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
     }
-    file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
       const processor = getStringifyProcessor();
-      file.data._markdown = toMarkdown(tree, {
+      const markdown = toMarkdown(tree, {
         ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
         extensions: processor.data("toMarkdownExtensions") || []
       });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
     }
     if (includeMDAST) {
       const options = includeMDAST === true ? {} : includeMDAST;
-      file.data._mdast = JSON.stringify(
+      const mdast = JSON.stringify(
         options.removePosition ? removePosition(structuredClone(tree)) : tree
       );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
     }
-    for (const { name, value } of file.data["mdx-export"] ?? []) {
+    for (const { name, value } of file.data["mdx-export"]) {
       tree.children.unshift(getMdastExport(name, value));
     }
+    file.data["mdx-export"] = [];
     for (const name of valueToExport) {
       if (!(name in file.data)) continue;
       tree.children.unshift(getMdastExport(name, file.data[name]));
@@ -97,43 +117,39 @@ function getMdastExport(name, value) {
     }
   };
 }
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 
 // src/loaders/mdx/build-mdx.ts
-var cache = /* @__PURE__ */ new Map();
-async function buildMDX(cacheKey, source, options) {
-  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+async function buildMDX(core, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
   function getProcessor(format) {
-    const key = `${cacheKey}:${format}`;
+    const cache = core.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
     let processor = cache.get(key);
     if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess,
+        valueToExport: [
+          ...collection?.postprocess?.valueToExport ?? [],
+          "structuredData",
+          "frontmatter"
+        ]
+      };
       processor = createProcessor({
         outputFormat: "program",
-        ...rest,
+        development: isDevelopment,
+        ...mdxOptions,
         remarkPlugins: [
           remarkInclude,
-          ...rest.remarkPlugins ?? [],
-          [
-            remarkPostprocess,
-            {
-              _format: format,
-              ...options.postprocess,
-              valueToExport: [
-                ...options.postprocess?.valueToExport ?? [],
-                "structuredData",
-                "extractedReferences",
-                "frontmatter",
-                "lastModified",
-                "_markdown",
-                "_mdast"
-              ]
-            }
-          ]
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
         ],
         format
       });
@@ -141,18 +157,15 @@ async function buildMDX(cacheKey, source, options) {
     }
     return processor;
   }
-  return getProcessor(
-    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
-  ).process({
+  let vfile = new VFile({
     value: source,
     path: filePath,
-    data: {
-      ...data,
-      frontmatter,
-      _compiler,
-      _getProcessor: getProcessor
-    }
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
+  if (collection) {
+    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
 }
 
 export {