fumadocs-mdx 12.0.0 → 12.0.2

package/dist/bun/index.cjs

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/mdx/preset.ts
+// src/loaders/mdx/preset.ts
 var preset_exports = {};
 __export(preset_exports, {
   getDefaultMDXOptions: () => getDefaultMDXOptions
@@ -111,12 +111,67 @@ function getDefaultMDXOptions({
 }
 var plugins;
 var init_preset = __esm({
-  "src/mdx/preset.ts"() {
+  "src/loaders/mdx/preset.ts"() {
     "use strict";
     plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
   }
 });
 
+// src/config/build.ts
+function buildConfig(config) {
+  const collections = /* @__PURE__ */ new Map();
+  let globalConfig = {};
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "type" in v) {
+      if (v.type === "docs") {
+        collections.set(k, v);
+        continue;
+      }
+      if (v.type === "doc" || v.type === "meta") {
+        collections.set(k, v);
+        continue;
+      }
+    }
+    if (k === "default" && v) {
+      globalConfig = v;
+      continue;
+    }
+    throw new Error(
+      `Unknown export "${k}", you can only export collections from source configuration file.`
+    );
+  }
+  const mdxOptionsCache = /* @__PURE__ */ new Map();
+  return {
+    global: globalConfig,
+    collections,
+    async getDefaultMDXOptions(mode = "default") {
+      const cached = mdxOptionsCache.get(mode);
+      if (cached) return cached;
+      const input = this.global.mdxOptions;
+      async function uncached() {
+        const options = typeof input === "function" ? await input() : input;
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
+        if (options?.preset === "minimal") return options;
+        return getDefaultMDXOptions2({
+          ...options,
+          _withoutBundler: mode === "remote"
+        });
+      }
+      const result = uncached();
+      mdxOptionsCache.set(mode, result);
+      return result;
+    }
+  };
+}
+var init_build = __esm({
+  "src/config/build.ts"() {
+    "use strict";
+  }
+});
+
 // src/bun/index.ts
 var bun_exports = {};
 __export(bun_exports, {
@@ -201,19 +256,10 @@ async function getGitTimestamp(file) {
   }
 }
 
-// src/utils/count-lines.ts
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
-}
-
-// src/mdx/build-mdx.ts
+// src/loaders/mdx/build-mdx.ts
 var import_mdx = require("@mdx-js/mdx");
 
-// src/mdx/remark-include.ts
+// src/loaders/mdx/remark-include.ts
 var import_unified = require("unified");
 var import_unist_util_visit = require("unist-util-visit");
 var path2 = __toESM(require("path"), 1);
@@ -221,7 +267,28 @@ var fs = __toESM(require("fs/promises"), 1);
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
-var baseProcessor = (0, import_unified.unified)().use(import_mdx_plugins.remarkHeading);
+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("");
@@ -238,21 +305,31 @@ function parseSpecifier(specifier) {
 }
 function extractSection(root, section) {
   let nodes;
-  for (const node of root.children) {
-    if (node.type === "mdxJsxFlowElement" && node.name === "section" && node.attributes.some(
-      (attr) => attr.type === "mdxJsxAttribute" && attr.name === "id" && attr.value === section
-    )) {
-      nodes = node.children;
-      break;
+  let capturingHeadingContent = false;
+  (0, import_unist_util_visit.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 (node.type === "heading" && node.data?.hProperties?.id === section) {
-      nodes = [node];
-      continue;
+    if (capturingHeadingContent) {
+      nodes?.push(node);
+      return "skip";
     }
-    if (!nodes) continue;
-    if (node.type === "heading") break;
-    nodes.push(node);
-  }
+    if (isElementLike(node) && node.name === "section") {
+      const attributes = parseElementAttributes(node);
+      if (attributes.id === section) {
+        nodes = node.children;
+        return false;
+      }
+    }
+  });
   if (nodes)
     return {
       type: "root",
@@ -284,55 +361,52 @@ ${e instanceof Error ? e.message : String(e)}`,
         data: {}
       };
     }
-    const processor = (data._getProcessor ?? getDefaultProcessor)(
+    const parser = (data._getProcessor ?? getDefaultProcessor)(
       ext === ".mdx" ? "mdx" : "md"
     );
-    let parsed = await baseProcessor.run(
-      processor.parse(fumaMatter(content).content)
-    );
+    const parsed = fumaMatter(content);
+    let mdast = parser.parse({
+      path: file,
+      value: parsed.content,
+      data: { frontmatter: parsed.data }
+    });
     if (heading) {
-      const extracted = extractSection(parsed, heading);
+      const extracted = extractSection(
+        await (0, import_unified.unified)().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.`
+          `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.`
         );
-      parsed = extracted;
+      mdast = extracted;
     }
-    await update(parsed, path2.dirname(file), data);
-    return parsed;
+    await update(mdast, path2.dirname(file), data);
+    return mdast;
   }
   async function update(tree, directory, data) {
     const queue = [];
-    (0, import_unist_util_visit.visit)(
-      tree,
-      ["mdxJsxFlowElement", "mdxJsxTextElement"],
-      (_node, _, parent) => {
-        const node = _node;
-        if (node.name !== TagName) return;
-        const params = {};
-        const specifier = flattenNode(node);
-        if (specifier.length === 0) return "skip";
-        for (const attr of node.attributes) {
-          if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
-            params[attr.name] = attr.value;
-          }
-        }
-        const { file: relativePath, section } = parseSpecifier(specifier);
-        const file = path2.resolve(
-          "cwd" in params ? process.cwd() : directory,
-          relativePath
-        );
-        queue.push(
-          embedContent(file, section, params, data).then((replace) => {
-            Object.assign(
-              parent && parent.type === "paragraph" ? parent : node,
-              replace
-            );
-          })
-        );
-        return "skip";
-      }
-    );
+    (0, import_unist_util_visit.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 = path2.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) => {
@@ -345,7 +419,7 @@ function getDefaultProcessor(format) {
   return mdProcessor.use(import_remark_mdx.default);
 }
 
-// src/mdx/remark-postprocess.ts
+// src/loaders/mdx/remark-postprocess.ts
 var import_unist_util_visit2 = require("unist-util-visit");
 var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
 var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
@@ -374,7 +448,7 @@ function remarkPostprocess({
     if (includeProcessedMarkdown) {
       file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
         ...this.data("settings"),
-        // @ts-expect-error - from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
         extensions: this.data("toMarkdownExtensions") || []
       });
     }
@@ -428,7 +502,7 @@ function flattenNode2(node) {
   return "";
 }
 
-// src/mdx/build-mdx.ts
+// src/loaders/mdx/build-mdx.ts
 var cache2 = /* @__PURE__ */ new Map();
 async function buildMDX(cacheKey, source, options) {
   const { filePath, frontmatter, data, _compiler, ...rest } = options;
@@ -464,7 +538,7 @@ async function buildMDX(cacheKey, source, options) {
     return processor;
   }
   return getProcessor(
-    options.format ?? filePath.endsWith(".mdx") ? "mdx" : "md"
+    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
   ).process({
     value: source,
     path: filePath,
@@ -477,7 +551,7 @@ async function buildMDX(cacheKey, source, options) {
   });
 }
 
-// src/loaders/mdx.ts
+// src/loaders/mdx/index.ts
 var import_zod = require("zod");
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
@@ -576,68 +650,19 @@ function createMdxLoader(configLoader) {
 function generateCacheHash(input) {
   return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
 }
-
-// src/utils/config.ts
-var fs3 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
-var import_node_url = require("url");
-
-// src/config/build.ts
-function buildConfig(config) {
-  const collections = /* @__PURE__ */ new Map();
-  let globalConfig = {};
-  for (const [k, v] of Object.entries(config)) {
-    if (!v) {
-      continue;
-    }
-    if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs") {
-        collections.set(k, v);
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(k, v);
-        continue;
-      }
-    }
-    if (k === "default" && v) {
-      globalConfig = v;
-      continue;
-    }
-    throw new Error(
-      `Unknown export "${k}", you can only export collections from source configuration file.`
-    );
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
   }
-  const mdxOptionsCache = /* @__PURE__ */ new Map();
-  return {
-    global: globalConfig,
-    collections,
-    async getDefaultMDXOptions(mode = "default") {
-      const cached = mdxOptionsCache.get(mode);
-      if (cached) return cached;
-      const input = this.global.mdxOptions;
-      async function uncached() {
-        const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
-        if (options?.preset === "minimal") return options;
-        return getDefaultMDXOptions2({
-          ...options,
-          _withoutBundler: mode === "remote"
-        });
-      }
-      const result = uncached();
-      mdxOptionsCache.set(mode, result);
-      return result;
-    }
-  };
+  return num;
 }
 
-// src/utils/config.ts
+// src/loaders/config/index.ts
+var import_node_path3 = __toESM(require("path"), 1);
 function findConfigFile() {
-  return path4.resolve("source.config.ts");
+  return import_node_path3.default.resolve("source.config.ts");
 }
-
-// src/loaders/config-loader.ts
 function resolvedConfig(loaded) {
   return {
     getConfig() {
@@ -647,12 +672,13 @@ function resolvedConfig(loaded) {
 }
 
 // src/bun/index.ts
+init_build();
 var import_node_querystring = require("querystring");
-var import_node_url2 = require("url");
+var import_node_url = require("url");
 function createMdxPlugin(options = {}) {
   const { configPath = findConfigFile() } = options;
   async function getMdxLoader() {
-    const importPath = (0, import_node_url2.pathToFileURL)(configPath).href;
+    const importPath = (0, import_node_url.pathToFileURL)(configPath).href;
     const out = buildConfig(await import(importPath));
     return createMdxLoader(resolvedConfig(out));
   }

package/dist/bun/index.js

@@ -1,16 +1,16 @@
 import {
-  createMdxLoader,
-  resolvedConfig
-} from "../chunk-KGUBBRL6.js";
-import "../chunk-IQAEAI4P.js";
+  buildConfig
+} from "../chunk-U4MQ44TS.js";
 import {
-  findConfigFile
-} from "../chunk-POXTQZ4D.js";
-import "../chunk-SWNOXPYJ.js";
-import "../chunk-KTDVTBMH.js";
+  createMdxLoader
+} from "../chunk-RMDXSZYE.js";
+import "../chunk-QAUWMR5D.js";
+import "../chunk-LMG6UWCL.js";
+import "../chunk-IQAEAI4P.js";
 import {
-  buildConfig
-} from "../chunk-YC25YEBF.js";
+  findConfigFile,
+  resolvedConfig
+} from "../chunk-XMFLD5J6.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/bun/index.ts

package/dist/chunk-ADR6R7HM.js

@@ -0,0 +1,29 @@
+// src/next/map/file-cache.ts
+import { LRUCache } from "lru-cache";
+import fs from "fs/promises";
+import path from "path";
+var map = new LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.relative(process.cwd(), file);
+  }
+  return file;
+}
+async function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = fs.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+export {
+  readFileWithCache,
+  removeFileCache
+};

package/dist/{chunk-3M4SHY6K.js → chunk-FSZMKRVH.js}

@@ -1,4 +1,4 @@
-// src/mdx/preset.ts
+// 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(

package/dist/{chunk-POXTQZ4D.js → chunk-LGYVNESJ.js}

@@ -1,14 +1,11 @@
 import {
   buildConfig
-} from "./chunk-YC25YEBF.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 compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
@@ -54,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
+};