fumadocs-mdx 11.10.1 → 12.0.1

package/dist/{chunk-UOOPSLFY.js → chunk-AUOOMFAI.js}

@@ -1,23 +1,29 @@
+import {
+  missingProcessedMarkdown
+} from "./chunk-ZLCSVXCD.js";
+
 // src/runtime/next/index.ts
-import fs from "fs";
-var cache = /* @__PURE__ */ new Map();
+import * as fs from "fs/promises";
 var _runtime = {
   doc(files) {
     return files.map((file) => {
-      const { default: body, frontmatter, ...exports } = file.data;
+      const data = file.data;
+      const filePath = file.info.fullPath;
       return {
-        body,
-        ...exports,
-        ...frontmatter,
-        _file: file.info,
-        _exports: file.data,
-        get content() {
-          const path = this._file.absolutePath;
-          const cached = cache.get(path);
-          if (cached) return cached;
-          const content = fs.readFileSync(path).toString();
-          cache.set(path, content);
-          return content;
+        info: file.info,
+        _exports: data,
+        body: data.default,
+        lastModified: data.lastModified,
+        toc: data.toc,
+        structuredData: data.structuredData,
+        extractedReferences: data.extractedReferences,
+        ...data.frontmatter,
+        async getText(type) {
+          if (type === "raw") {
+            return (await fs.readFile(filePath)).toString();
+          }
+          if (typeof data._markdown !== "string") missingProcessedMarkdown();
+          return data._markdown;
         }
       };
     });
@@ -25,8 +31,8 @@ var _runtime = {
   meta(files) {
     return files.map((file) => {
       return {
-        ...file.data,
-        _file: file.info
+        info: file.info,
+        ...file.data
       };
     });
   },
@@ -55,16 +61,16 @@ function resolveFiles({ docs, meta }) {
   for (const entry of docs) {
     outputs.push({
       type: "page",
-      absolutePath: entry._file.absolutePath,
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }
   for (const entry of meta) {
     outputs.push({
       type: "meta",
-      absolutePath: entry._file.absolutePath,
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }

package/dist/chunk-FSZMKRVH.js

@@ -0,0 +1,80 @@
+// src/loaders/mdx/preset.ts
+import * as plugins from "fumadocs-core/mdx-plugins";
+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,
+  remarkCodeTabOptions,
+  remarkNpmOptions,
+  _withoutBundler = false,
+  ...mdxOptions
+}) {
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [
+        plugins.remarkImage,
+        {
+          ...remarkImageOptions,
+          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
+        }
+      ],
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+        plugins.remarkCodeTab,
+        remarkCodeTabOptions
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      () => {
+        return (_, file) => {
+          file.data["mdx-export"] ??= [];
+          for (const name of valueToExport) {
+            if (name in file.data)
+              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: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+
+export {
+  getDefaultMDXOptions
+};

package/dist/{chunk-766EAFX6.js → chunk-LGYVNESJ.js}

@@ -1,44 +1,12 @@
 import {
   buildConfig
-} from "./chunk-QVZ7JH4H.js";
+} from "./chunk-U4MQ44TS.js";
 
-// src/utils/config.ts
+// src/loaders/config/load.ts
 import * as fs from "fs/promises";
 import * as path from "path";
 import { pathToFileURL } from "url";
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
 var cache = null;
-async function isZod3() {
-  try {
-    const content = JSON.parse(
-      (await fs.readFile("node_modules/zod/package.json")).toString()
-    );
-    const version = content.version;
-    return typeof version === "string" && version.startsWith("3.");
-  } catch {
-    return false;
-  }
-}
-function createCompatZodPlugin() {
-  return {
-    name: "replace-zod-import",
-    async setup(build) {
-      const usingZod3 = await isZod3();
-      if (!usingZod3) return;
-      console.warn(
-        "[Fumadocs MDX] Noticed Zod v3 in your node_modules, we recommend upgrading to Zod v4 for better compatibility."
-      );
-      build.onResolve({ filter: /^fumadocs-mdx\/config$/ }, () => {
-        return {
-          path: "fumadocs-mdx/config/zod-3",
-          external: true
-        };
-      });
-    }
-  };
-}
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -50,7 +18,6 @@ async function compileConfig(configPath, outDir) {
     platform: "node",
     format: "esm",
     packages: "external",
-    plugins: [createCompatZodPlugin()],
     outExtension: {
       ".js": ".mjs"
     },
@@ -84,7 +51,6 @@ async function getConfigHash(configPath) {
 }
 
 export {
-  findConfigFile,
   loadConfig,
   getConfigHash
 };

package/dist/chunk-LMG6UWCL.js

@@ -0,0 +1,167 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/remark-include.ts
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import * as path from "path";
+import * as fs from "fs/promises";
+import remarkParse from "remark-parse";
+import remarkMdx from "remark-mdx";
+import { remarkHeading } from "fumadocs-core/mdx-plugins";
+var ElementLikeTypes = [
+  "mdxJsxFlowElement",
+  "mdxJsxTextElement",
+  "containerDirective",
+  "textDirective",
+  "leafDirective"
+];
+function isElementLike(node) {
+  return ElementLikeTypes.includes(node.type);
+}
+function parseElementAttributes(element) {
+  if (Array.isArray(element.attributes)) {
+    const attributes = {};
+    for (const attr of element.attributes) {
+      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
+        attributes[attr.name] = attr.value;
+      }
+    }
+    return attributes;
+  }
+  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 };
+  return {
+    file: specifier.slice(0, idx),
+    section: specifier.slice(idx + 1)
+  };
+}
+function extractSection(root, section) {
+  let nodes;
+  let capturingHeadingContent = false;
+  visit(root, (node) => {
+    if (node.type === "heading") {
+      if (capturingHeadingContent) {
+        return false;
+      }
+      if (node.data?.hProperties?.id === section) {
+        capturingHeadingContent = true;
+        nodes = [node];
+        return "skip";
+      }
+      return;
+    }
+    if (capturingHeadingContent) {
+      nodes?.push(node);
+      return "skip";
+    }
+    if (isElementLike(node) && node.name === "section") {
+      const attributes = parseElementAttributes(node);
+      if (attributes.id === section) {
+        nodes = node.children;
+        return false;
+      }
+    }
+  });
+  if (nodes)
+    return {
+      type: "root",
+      children: nodes
+    };
+}
+function remarkInclude() {
+  const TagName = "include";
+  async function embedContent(file, heading, params, data) {
+    let content;
+    try {
+      content = (await fs.readFile(file)).toString();
+    } catch (e) {
+      throw new Error(
+        `failed to read file ${file}
+${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+    const ext = path.extname(file);
+    data._compiler?.addDependency(file);
+    if (params.lang || ext !== ".md" && ext !== ".mdx") {
+      const lang = params.lang ?? ext.slice(1);
+      return {
+        type: "code",
+        lang,
+        meta: params.meta,
+        value: content,
+        data: {}
+      };
+    }
+    const parser = (data._getProcessor ?? getDefaultProcessor)(
+      ext === ".mdx" ? "mdx" : "md"
+    );
+    const parsed = fumaMatter(content);
+    let mdast = parser.parse({
+      path: file,
+      value: parsed.content,
+      data: { frontmatter: parsed.data }
+    });
+    if (heading) {
+      const extracted = extractSection(
+        await unified().use(remarkHeading).run(mdast),
+        heading
+      );
+      if (!extracted)
+        throw new Error(
+          `Cannot find section ${heading} in ${file}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
+        );
+      mdast = extracted;
+    }
+    await update(mdast, path.dirname(file), data);
+    return mdast;
+  }
+  async function update(tree, directory, data) {
+    const queue = [];
+    visit(tree, ElementLikeTypes, (_node, _, parent) => {
+      const node = _node;
+      if (node.name !== TagName) return;
+      const specifier = flattenNode(node);
+      if (specifier.length === 0) return "skip";
+      const attributes = parseElementAttributes(node);
+      const { file: relativePath, section } = parseSpecifier(specifier);
+      const file = path.resolve(
+        "cwd" in attributes ? process.cwd() : directory,
+        relativePath
+      );
+      queue.push(
+        embedContent(file, section, attributes, data).then((replace) => {
+          Object.assign(
+            parent && parent.type === "paragraph" ? parent : node,
+            replace
+          );
+        })
+      );
+      return "skip";
+    });
+    await Promise.all(queue);
+  }
+  return async (tree, file) => {
+    await update(tree, path.dirname(file.path), file.data);
+  };
+}
+function getDefaultProcessor(format) {
+  const mdProcessor = unified().use(remarkParse);
+  if (format === "md") return mdProcessor;
+  return mdProcessor.use(remarkMdx);
+}
+
+export {
+  remarkInclude
+};

package/dist/chunk-QAUWMR5D.js

@@ -0,0 +1,142 @@
+import {
+  remarkInclude
+} from "./chunk-LMG6UWCL.js";
+
+// src/loaders/mdx/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+
+// src/loaders/mdx/remark-postprocess.ts
+import { visit } from "unist-util-visit";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { valueToEstree } from "estree-util-value-to-estree";
+function remarkPostprocess({
+  includeProcessedMarkdown = false,
+  valueToExport = []
+} = {}) {
+  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
+      });
+      return "skip";
+    });
+    if (title) {
+      file.data.frontmatter ??= {};
+      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
+    }
+    file.data.extractedReferences = urls;
+    if (includeProcessedMarkdown) {
+      file.data._markdown = toMarkdown(tree, {
+        ...this.data("settings"),
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: this.data("toMarkdownExtensions") || []
+      });
+    }
+    for (const { name, value } of file.data["mdx-export"] ?? []) {
+      tree.children.unshift(getMdastExport(name, value));
+    }
+    for (const name of valueToExport) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            attributes: [],
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(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;
+  function getProcessor(format) {
+    const key = `${cacheKey}:${format}`;
+    let processor = cache.get(key);
+    if (!processor) {
+      processor = createProcessor({
+        outputFormat: "program",
+        ...rest,
+        remarkPlugins: [
+          remarkInclude,
+          ...rest.remarkPlugins ?? [],
+          [
+            remarkPostprocess,
+            {
+              ...options.postprocess,
+              valueToExport: [
+                ...options.postprocess?.valueToExport ?? [],
+                "structuredData",
+                "extractedReferences",
+                "frontmatter",
+                "lastModified",
+                "_markdown"
+              ]
+            }
+          ]
+        ],
+        format
+      });
+      cache.set(key, processor);
+    }
+    return processor;
+  }
+  return getProcessor(
+    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
+  ).process({
+    value: source,
+    path: filePath,
+    data: {
+      ...data,
+      frontmatter,
+      _compiler,
+      _getProcessor: getProcessor
+    }
+  });
+}
+
+export {
+  buildMDX
+};

package/dist/{chunk-QJCCVMBJ.js → chunk-SP7CHRTS.js}

@@ -1,28 +1,15 @@
-import {
-  buildMDX
-} from "./chunk-QQWCBFFE.js";
 import {
   getGitTimestamp,
   validate
 } from "./chunk-IQAEAI4P.js";
 import {
-  getConfigHash,
-  loadConfig
-} from "./chunk-766EAFX6.js";
+  buildMDX
+} from "./chunk-QAUWMR5D.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
 
-// src/utils/count-lines.ts
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
-}
-
-// src/loaders/mdx.ts
+// src/loaders/mdx/index.ts
 import { z } from "zod";
 import fs from "fs/promises";
 import path from "path";
@@ -57,21 +44,18 @@ function createMdxLoader(configLoader) {
       if (cached && cached.hash === generateCacheHash(value)) return cached;
     }
     const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
-    let schema;
-    let mdxOptions;
+    let docCollection;
     switch (collection?.type) {
       case "doc":
-        mdxOptions = collection.mdxOptions;
-        schema = collection.schema;
+        docCollection = collection;
         break;
       case "docs":
-        mdxOptions = collection.docs.mdxOptions;
-        schema = collection.docs.schema;
+        docCollection = collection.docs;
         break;
     }
-    if (schema) {
+    if (docCollection?.schema) {
       matter.data = await validate(
-        schema,
+        docCollection.schema,
         matter.data,
         {
           source: value,
@@ -96,7 +80,8 @@ function createMdxLoader(configLoader) {
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
-        ...mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        postprocess: docCollection?.postprocess,
         data,
         filePath,
         frontmatter: matter.data,
@@ -123,29 +108,14 @@ function createMdxLoader(configLoader) {
 function generateCacheHash(input) {
   return createHash("md5").update(input).digest("hex");
 }
-
-// src/loaders/config-loader.ts
-function resolvedConfig(loaded) {
-  return {
-    getConfig() {
-      return loaded;
-    }
-  };
-}
-function dynamicConfig(configPath, outDir) {
-  return {
-    async getConfig(hash) {
-      return loadConfig(
-        configPath,
-        outDir,
-        hash ?? await getConfigHash(configPath)
-      );
-    }
-  };
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
 }
 
 export {
-  createMdxLoader,
-  resolvedConfig,
-  dynamicConfig
+  createMdxLoader
 };

package/dist/{chunk-QVZ7JH4H.js → chunk-U4MQ44TS.js}

@@ -34,7 +34,7 @@ function buildConfig(config) {
       const input = this.global.mdxOptions;
       async function uncached() {
         const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions } = await import("./mdx-options-T73E4LQB.js");
+        const { getDefaultMDXOptions } = await import("./preset-ZMP6U62C.js");
         if (options?.preset === "minimal") return options;
         return getDefaultMDXOptions({
           ...options,

package/dist/{chunk-CNKI574E.js → chunk-VXEBLM4X.js}

@@ -57,7 +57,7 @@ function toWebpack(loader) {
     try {
       const result = await loader({
         filePath: this.resourcePath,
-        query: parse(this.resourceQuery),
+        query: parse(this.resourceQuery.slice(1)),
         source,
         development: this.mode === "development",
         compiler: this

package/dist/chunk-XMFLD5J6.js

@@ -0,0 +1,30 @@
+// src/loaders/config/index.ts
+import path from "path";
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+function resolvedConfig(loaded) {
+  return {
+    getConfig() {
+      return loaded;
+    }
+  };
+}
+function dynamicConfig(configPath, outDir) {
+  return {
+    async getConfig(hash) {
+      const { loadConfig, getConfigHash } = await import("./load-UUXLUBHL.js");
+      return loadConfig(
+        configPath,
+        outDir,
+        hash ?? await getConfigHash(configPath)
+      );
+    }
+  };
+}
+
+export {
+  findConfigFile,
+  resolvedConfig,
+  dynamicConfig
+};

package/dist/chunk-ZLCSVXCD.js

@@ -0,0 +1,10 @@
+// src/runtime/shared.ts
+function missingProcessedMarkdown() {
+  throw new Error(
+    "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+  );
+}
+
+export {
+  missingProcessedMarkdown
+};