fumadocs-mdx 11.6.0 → 13.0.1

package/dist/config/index.cjs

@@ -40,9 +40,8 @@ __export(config_exports, {
 });
 module.exports = __toCommonJS(config_exports);
 
-// src/utils/schema.ts
+// src/config/zod-4.ts
 var import_zod = require("zod");
-var import_picocolors = __toESM(require("picocolors"), 1);
 var metaSchema = import_zod.z.object({
   title: import_zod.z.string().optional(),
   pages: import_zod.z.array(import_zod.z.string()).optional(),
@@ -57,33 +56,24 @@ var frontmatterSchema = import_zod.z.object({
   icon: import_zod.z.string().optional(),
   full: import_zod.z.boolean().optional(),
   // Fumadocs OpenAPI generated
-  _openapi: import_zod.z.object({}).passthrough().optional()
+  _openapi: import_zod.z.looseObject({}).optional()
 });
 
 // src/config/define.ts
 function defineCollections(options) {
-  return {
-    // @ts-expect-error -- internal type inferring
-    _type: void 0,
-    ...options
-  };
+  return options;
 }
 function defineDocs(options) {
-  if (!options)
-    console.warn(
-      "[`source.config.ts`] Deprecated: please pass options to `defineDocs()` and specify a `dir`."
-    );
-  const dir = options?.dir ?? "content/docs";
+  const dir = options.dir ?? "content/docs";
   return {
     type: "docs",
-    // @ts-expect-error -- internal type inferring
+    dir,
     docs: defineCollections({
       type: "doc",
       dir,
       schema: frontmatterSchema,
       ...options?.docs
     }),
-    // @ts-expect-error -- internal type inferring
     meta: defineCollections({
       type: "meta",
       dir,
@@ -96,54 +86,8 @@ function defineConfig(config = {}) {
   return config;
 }
 
-// src/utils/mdx-options.ts
+// src/loaders/mdx/preset.ts
 var plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-
-// 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
@@ -160,14 +104,10 @@ function getDefaultMDXOptions({
   remarkHeadingOptions,
   remarkStructureOptions,
   remarkCodeTabOptions,
+  remarkNpmOptions,
+  _withoutBundler = false,
   ...mdxOptions
 }) {
-  const mdxExports = [
-    "structuredData",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
   const remarkPlugins = pluginOption(
     (v) => [
       plugins.remarkGfm,
@@ -178,15 +118,32 @@ function getDefaultMDXOptions({
           ...remarkHeadingOptions
         }
       ],
-      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
-      // Fumadocs 14 compatibility
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && plugins.remarkCodeTab,
+      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
       ],
-      [remarkMdxExport, { values: mdxExports }]
+      () => {
+        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
   );
@@ -194,86 +151,233 @@ function getDefaultMDXOptions({
     (v) => [
       rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
       ...v,
-      [plugins.rehypeToc]
+      plugins.rehypeToc
     ],
     mdxOptions.rehypePlugins
   );
   return {
     ...mdxOptions,
+    outputFormat: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
     remarkPlugins,
     rehypePlugins
   };
 }
 
-// src/mdx-plugins/remark-include.ts
-var import_unist_util_visit = require("unist-util-visit");
+// src/loaders/mdx/remark-include.ts
+var import_unified = require("unified");
+var import_unist_util_visit2 = 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);
+
+// src/utils/fuma-matter.ts
+var import_js_yaml = require("js-yaml");
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = (0, import_js_yaml.load)(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+// src/loaders/mdx/remark-include.ts
+var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+
+// src/loaders/mdx/remark-unravel.ts
+var import_unist_util_visit = require("unist-util-visit");
+function remarkMarkAndUnravel() {
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, function(node, index, parent) {
+      let offset = -1;
+      let all = true;
+      let oneOrMore = false;
+      if (parent && typeof index === "number" && node.type === "paragraph") {
+        const children = node.children;
+        while (++offset < children.length) {
+          const child = children[offset];
+          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
+            oneOrMore = true;
+          } else if (child.type === "text" && child.value.trim().length === 0) {
+          } else {
+            all = false;
+            break;
+          }
+        }
+        if (all && oneOrMore) {
+          offset = -1;
+          const newChildren = [];
+          while (++offset < children.length) {
+            const child = children[offset];
+            if (child.type === "mdxJsxTextElement") {
+              child.type = "mdxJsxFlowElement";
+            }
+            if (child.type === "mdxTextExpression") {
+              child.type = "mdxFlowExpression";
+            }
+            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
+            } else {
+              newChildren.push(child);
+            }
+          }
+          parent.children.splice(index, 1, ...newChildren);
+          return index;
+        }
+      }
+    });
+  };
+}
+
+// src/loaders/mdx/remark-include.ts
+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;
+  (0, import_unist_util_visit2.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 update(tree, file, processor, compiler) {
-    const queue = [];
-    (0, import_unist_util_visit.visit)(
-      tree,
-      ["mdxJsxFlowElement", "mdxJsxTextElement"],
-      (node, _, parent) => {
-        let specifier;
-        const params = {};
-        if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && node.name === TagName) {
-          const value = flattenNode(node);
-          if (value.length > 0) {
-            for (const attr of node.attributes) {
-              if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
-                params[attr.name] = attr.value;
-              }
-            }
-            specifier = value;
-          }
-        }
-        if (!specifier) return;
-        const targetPath = path.resolve(
-          "cwd" in params ? process.cwd() : path.dirname(file),
-          specifier
-        );
-        const asCode = params.lang || !specifier.endsWith(".md") && !specifier.endsWith(".mdx");
-        queue.push(
-          fs.readFile(targetPath).then(async (content) => {
-            compiler?.addDependency(targetPath);
-            if (asCode) {
-              const lang = params.lang ?? path.extname(specifier).slice(1);
-              Object.assign(node, {
-                type: "code",
-                lang,
-                meta: params.meta,
-                value: content.toString(),
-                data: {}
-              });
-              return;
-            }
-            const parsed = processor.parse((0, import_gray_matter.default)(content).content);
-            await update(parsed, targetPath, processor, compiler);
-            Object.assign(
-              parent && parent.type === "paragraph" ? parent : node,
-              parsed
-            );
-          }).catch((e) => {
-            console.warn(`failed to read file: ${targetPath}`, e);
-          })
+  const embedContent = async (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 ? data._getProcessor(ext === ".mdx" ? "mdx" : "md") : this;
+    const parsed = fumaMatter(content);
+    let mdast = parser.parse({
+      path: file,
+      value: parsed.content,
+      data: { frontmatter: parsed.data }
+    });
+    const baseProcessor = (0, import_unified.unified)().use(remarkMarkAndUnravel);
+    if (heading) {
+      const extracted = extractSection(
+        await baseProcessor.use(import_mdx_plugins.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.`
         );
-        return "skip";
-      }
-    );
+      mdast = extracted;
+    } else {
+      mdast = await baseProcessor.run(mdast);
+    }
+    await update(mdast, path.dirname(file), data);
+    return mdast;
+  };
+  async function update(tree, directory, data) {
+    const queue = [];
+    (0, import_unist_util_visit2.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, file.path, this, file.data._compiler);
+    await update(tree, path.dirname(file.path), file.data);
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/config/index.d.cts

@@ -1,13 +1,11 @@
-export { c as BaseCollection, B as BaseCollectionEntry, C as CollectionSchema, h as DefaultMDXOptions, D as DocCollection, a as DocsCollection, F as FileInfo, G as GlobalConfig, b as MarkdownProps, M as MetaCollection, d as defineCollections, g as defineConfig, e as defineDocs, f as frontmatterSchema, i as getDefaultMDXOptions, m as metaSchema } from '../define-BaW0PQDJ.cjs';
+export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, D as DefaultMDXOptions, b as DocCollection, c as DocsCollection, G as GlobalConfig, M as MetaCollection, P as PostprocessOptions, d as defineCollections, f as defineConfig, e as defineDocs, h as frontmatterSchema, g as getDefaultMDXOptions, m as metaSchema } from '../core-B6j6Fxse.cjs';
 import { Processor, Transformer } from 'unified';
 import { Root } from 'mdast';
-import '@mdx-js/mdx';
-import 'mdx/types';
+import '@standard-schema/spec';
 import 'fumadocs-core/mdx-plugins';
-import 'fumadocs-core/server';
-import 'react';
+import '@mdx-js/mdx';
 import 'zod';
-import '@standard-schema/spec';
+import 'chokidar';
 
 declare function remarkInclude(this: Processor): Transformer<Root, Root>;
 

package/dist/config/index.d.ts

@@ -1,13 +1,11 @@
-export { c as BaseCollection, B as BaseCollectionEntry, C as CollectionSchema, h as DefaultMDXOptions, D as DocCollection, a as DocsCollection, F as FileInfo, G as GlobalConfig, b as MarkdownProps, M as MetaCollection, d as defineCollections, g as defineConfig, e as defineDocs, f as frontmatterSchema, i as getDefaultMDXOptions, m as metaSchema } from '../define-BaW0PQDJ.js';
+export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, D as DefaultMDXOptions, b as DocCollection, c as DocsCollection, G as GlobalConfig, M as MetaCollection, P as PostprocessOptions, d as defineCollections, f as defineConfig, e as defineDocs, h as frontmatterSchema, g as getDefaultMDXOptions, m as metaSchema } from '../core-B6j6Fxse.js';
 import { Processor, Transformer } from 'unified';
 import { Root } from 'mdast';
-import '@mdx-js/mdx';
-import 'mdx/types';
+import '@standard-schema/spec';
 import 'fumadocs-core/mdx-plugins';
-import 'fumadocs-core/server';
-import 'react';
+import '@mdx-js/mdx';
 import 'zod';
-import '@standard-schema/spec';
+import 'chokidar';
 
 declare function remarkInclude(this: Processor): Transformer<Root, Root>;
 

package/dist/config/index.js

@@ -1,38 +1,45 @@
 import {
-  frontmatterSchema,
-  metaSchema
-} from "../chunk-2ZOW45YZ.js";
+  getDefaultMDXOptions
+} from "../chunk-FSZMKRVH.js";
 import {
   remarkInclude
-} from "../chunk-MK7EXW7O.js";
-import {
-  getDefaultMDXOptions
-} from "../chunk-IOENRFUX.js";
+} from "../chunk-K5ZLPEIQ.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/config/zod-4.ts
+import { z } from "zod";
+var metaSchema = z.object({
+  title: z.string().optional(),
+  pages: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  root: z.boolean().optional(),
+  defaultOpen: z.boolean().optional(),
+  icon: z.string().optional()
+});
+var frontmatterSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  full: z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: z.looseObject({}).optional()
+});
 
 // src/config/define.ts
 function defineCollections(options) {
-  return {
-    // @ts-expect-error -- internal type inferring
-    _type: void 0,
-    ...options
-  };
+  return options;
 }
 function defineDocs(options) {
-  if (!options)
-    console.warn(
-      "[`source.config.ts`] Deprecated: please pass options to `defineDocs()` and specify a `dir`."
-    );
-  const dir = options?.dir ?? "content/docs";
+  const dir = options.dir ?? "content/docs";
   return {
     type: "docs",
-    // @ts-expect-error -- internal type inferring
+    dir,
     docs: defineCollections({
       type: "doc",
       dir,
       schema: frontmatterSchema,
       ...options?.docs
     }),
-    // @ts-expect-error -- internal type inferring
     meta: defineCollections({
       type: "meta",
       dir,