fumadocs-mdx 11.10.1 → 12.0.1

package/dist/loader-mdx.js

@@ -1,15 +1,15 @@
 import {
   toWebpack
-} from "./chunk-CNKI574E.js";
+} from "./chunk-VXEBLM4X.js";
 import {
-  createMdxLoader,
-  dynamicConfig
-} from "./chunk-QJCCVMBJ.js";
-import "./chunk-QQWCBFFE.js";
-import "./chunk-SVTXMVLQ.js";
+  createMdxLoader
+} from "./chunk-SP7CHRTS.js";
 import "./chunk-IQAEAI4P.js";
-import "./chunk-766EAFX6.js";
-import "./chunk-QVZ7JH4H.js";
+import {
+  dynamicConfig
+} from "./chunk-XMFLD5J6.js";
+import "./chunk-QAUWMR5D.js";
+import "./chunk-LMG6UWCL.js";
 import "./chunk-VWJKRQZR.js";
 
 // src/loader-mdx.ts

package/dist/next/index.cjs

@@ -30,86 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/mdx-plugins/remark-postprocess.ts
-function remarkPostprocess({
-  injectExports
-}) {
-  return (tree, file) => {
-    let title;
-    const urls = [];
-    (0, import_unist_util_visit.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;
-    for (const name of injectExports) {
-      if (!(name in file.data)) continue;
-      tree.children.unshift(getMdastExport(name, file.data[name]));
-    }
-  };
-}
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
-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: (0, import_estree_util_value_to_estree.valueToEstree)(value)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-var import_unist_util_visit, import_estree_util_value_to_estree;
-var init_remark_postprocess = __esm({
-  "src/mdx-plugins/remark-postprocess.ts"() {
-    "use strict";
-    import_unist_util_visit = require("unist-util-visit");
-    import_estree_util_value_to_estree = require("estree-util-value-to-estree");
-  }
-});
-
-// src/utils/mdx-options.ts
-var mdx_options_exports = {};
-__export(mdx_options_exports, {
+// src/loaders/mdx/preset.ts
+var preset_exports = {};
+__export(preset_exports, {
   getDefaultMDXOptions: () => getDefaultMDXOptions
 });
 function pluginOption(def, options = []) {
@@ -132,13 +55,6 @@ function getDefaultMDXOptions({
   _withoutBundler = false,
   ...mdxOptions
 }) {
-  const mdxExports = [
-    "structuredData",
-    "extractedReferences",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
   const remarkPlugins = pluginOption(
     (v) => [
       plugins.remarkGfm,
@@ -166,10 +82,15 @@ function getDefaultMDXOptions({
         plugins.remarkStructure,
         remarkStructureOptions
       ],
-      [
-        remarkPostprocess,
-        { injectExports: 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
   );
@@ -189,58 +110,13 @@ function getDefaultMDXOptions({
   };
 }
 var plugins;
-var init_mdx_options = __esm({
-  "src/utils/mdx-options.ts"() {
+var init_preset = __esm({
+  "src/loaders/mdx/preset.ts"() {
     "use strict";
     plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-    init_remark_postprocess();
   }
 });
 
-// src/map/watcher.ts
-var watcher_exports = {};
-__export(watcher_exports, {
-  watcher: () => watcher
-});
-function watcher(configPath, config, ignored) {
-  const watcher2 = new import_chokidar.FSWatcher({
-    ignoreInitial: true,
-    persistent: true,
-    ignored
-  });
-  watcher2.add(configPath);
-  for (const collection of config.collections.values()) {
-    if (collection.type === "docs") {
-      watcher2.add(collection.docs.dir);
-      watcher2.add(collection.meta.dir);
-    } else {
-      watcher2.add(collection.dir);
-    }
-  }
-  return watcher2;
-}
-var import_chokidar;
-var init_watcher = __esm({
-  "src/map/watcher.ts"() {
-    "use strict";
-    import_chokidar = require("chokidar");
-  }
-});
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall,
-  start: () => start
-});
-module.exports = __toCommonJS(next_exports);
-
-// src/utils/config.ts
-var fs = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-
 // src/config/build.ts
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
@@ -277,7 +153,7 @@ function buildConfig(config) {
       const input = this.global.mdxOptions;
       async function uncached() {
         const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
         if (options?.preset === "minimal") return options;
         return getDefaultMDXOptions2({
           ...options,
@@ -290,41 +166,13 @@ function buildConfig(config) {
     }
   };
 }
-
-// src/utils/config.ts
-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;
+var init_build = __esm({
+  "src/config/build.ts"() {
+    "use strict";
   }
-}
-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
-        };
-      });
-    }
-  };
-}
+});
+
+// src/loaders/config/load.ts
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -336,7 +184,6 @@ async function compileConfig(configPath, outDir) {
     platform: "node",
     format: "esm",
     packages: "external",
-    plugins: [createCompatZodPlugin()],
     outExtension: {
       ".js": ".mjs"
     },
@@ -368,14 +215,63 @@ async function getConfigHash(configPath) {
   }
   throw new Error("Cannot find config file");
 }
+var fs, path, import_node_url, cache;
+var init_load = __esm({
+  "src/loaders/config/load.ts"() {
+    "use strict";
+    fs = __toESM(require("fs/promises"), 1);
+    path = __toESM(require("path"), 1);
+    import_node_url = require("url");
+    init_build();
+    cache = null;
+  }
+});
+
+// src/next/map/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  watcher: () => watcher
+});
+function watcher(configPath, config, ignored) {
+  const watcher2 = new import_chokidar.FSWatcher({
+    ignoreInitial: true,
+    persistent: true,
+    ignored
+  });
+  watcher2.add(configPath);
+  for (const collection of config.collections.values()) {
+    if (collection.type === "docs") {
+      watcher2.add(collection.docs.dir);
+      watcher2.add(collection.meta.dir);
+    } else {
+      watcher2.add(collection.dir);
+    }
+  }
+  return watcher2;
+}
+var import_chokidar;
+var init_watcher = __esm({
+  "src/next/map/watcher.ts"() {
+    "use strict";
+    import_chokidar = require("chokidar");
+  }
+});
 
 // src/next/index.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall,
+  start: () => start
+});
+module.exports = __toCommonJS(next_exports);
+init_load();
+var import_node_path5 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 
-// src/map/generate.ts
-var path4 = __toESM(require("path"), 1);
-var fs2 = __toESM(require("fs/promises"), 1);
+// src/next/map/generate.ts
+var path5 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
 var import_tinyglobby = require("tinyglobby");
 
 // src/utils/validation.ts
@@ -416,31 +312,36 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
-// src/map/file-cache.ts
+// src/next/map/file-cache.ts
 var import_lru_cache = require("lru-cache");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var map = new import_lru_cache.LRUCache({
-  max: 200
+  max: 100
 });
-var fileCache = {
-  read(namespace, path7) {
-    return map.get(`${namespace}.${path7}`);
-  },
-  write(namespace, path7, data) {
-    map.set(`${namespace}.${path7}`, data);
-  },
-  removeCache(path7) {
-    for (const key of map.keys()) {
-      const keyPath = key.slice(key.indexOf(".") + 1);
-      if (keyPath === path7) map.delete(key);
-    }
+function toFullPath(file) {
+  if (import_node_path.default.isAbsolute(file)) {
+    return import_node_path.default.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 = import_promises.default.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
 
-// src/map/generate.ts
+// src/next/map/generate.ts
 var import_js_yaml2 = require("js-yaml");
 
 // src/utils/git-timestamp.ts
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_tinyexec = require("tinyexec");
 var cache2 = /* @__PURE__ */ new Map();
 async function getGitTimestamp(file) {
@@ -449,7 +350,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -479,7 +380,7 @@ function fumaMatter(input) {
 }
 
 // src/utils/import-formatter.ts
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 function getImportCode(info) {
   const specifier = JSON.stringify(info.specifier);
   if (info.type === "default") return `import ${info.name} from ${specifier}`;
@@ -494,7 +395,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path2.default.extname(file);
+  const ext = import_node_path3.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -505,14 +406,14 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path2.default.relative(config.relativeTo, filename);
-    if (!import_node_path2.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path3.default.relative(config.relativeTo, filename);
+    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path2.default.resolve(filename);
+    importPath = import_node_path3.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path2.default.sep, "/");
+  return importPath.replaceAll(import_node_path3.default.sep, "/");
 }
 
 // src/utils/collections.ts
@@ -533,12 +434,7 @@ function isFileSupported(filePath, collection) {
   return false;
 }
 
-// src/map/generate.ts
-async function readFileWithCache(file) {
-  const cached = fileCache.read("read-file", file);
-  if (cached) return cached;
-  return (await fs2.readFile(file)).toString();
-}
+// src/next/map/generate.ts
 async function generateJS(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
@@ -565,7 +461,7 @@ async function generateJS(configPath, config, importPath, configHash = false) {
         getImportCode({
           type: "namespace",
           name: importId,
-          specifier: `${toImportPath(file.absolutePath, importPath)}?${params.join("&")}`
+          specifier: `${toImportPath(file.fullPath, importPath)}?${params.join("&")}`
         })
       );
       return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
@@ -574,17 +470,17 @@ async function generateJS(configPath, config, importPath, configHash = false) {
   }
   async function getMetaEntries(collection, files) {
     const items = files.map(async (file) => {
-      const source = await readFileWithCache(file.absolutePath).catch(() => "");
-      let data = source.length === 0 ? {} : parseMetaEntry(file.absolutePath, source);
+      const source = await readFileWithCache(file.fullPath).catch(() => "");
+      let data = source.length === 0 ? {} : parseMetaEntry(file.fullPath, source);
       if (collection?.schema) {
         data = await validate(
           collection.schema,
           data,
           {
             source,
-            path: file.absolutePath
+            path: file.fullPath
           },
-          `invalid data in ${file.absolutePath}`
+          `invalid data in ${file.fullPath}`
         );
       }
       return JSON.stringify({
@@ -602,33 +498,40 @@ async function generateJS(configPath, config, importPath, configHash = false) {
           specifier: "fumadocs-mdx/runtime/async",
           names: ["_runtimeAsync", "buildConfig"]
         }),
-        "const _sourceConfig = buildConfig(_source)"
+        "const _sourceConfig = buildConfig(_source)",
+        getImportCode({
+          type: "default",
+          name: "path",
+          specifier: "node:path"
+        })
       );
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
-      const parsed = fumaMatter(
-        await readFileWithCache(file.absolutePath).catch(() => "")
-      );
+      const content = await readFileWithCache(file.fullPath).catch(() => "");
+      const parsed = fumaMatter(content);
       let data = parsed.data;
       if (collection.schema) {
         data = await validate(
           collection.schema,
           parsed.data,
-          { path: file.absolutePath, source: parsed.content },
-          `invalid frontmatter in ${file.absolutePath}`
+          { path: file.fullPath, source: parsed.content },
+          `invalid frontmatter in ${file.fullPath}`
         );
       }
       let lastModified;
       if (config.global?.lastModifiedTime === "git") {
-        lastModified = await getGitTimestamp(file.absolutePath);
+        lastModified = await getGitTimestamp(file.fullPath);
       }
-      return JSON.stringify({
-        info: file,
-        lastModified,
-        data,
-        content: { body: parsed.content, matter: parsed.matter }
-      });
+      const hash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+      const infoStr = [];
+      for (const [k, v] of Object.entries({ ...file, hash })) {
+        infoStr.push(`${k}: ${JSON.stringify(v)}`);
+      }
+      infoStr.push(
+        `absolutePath: path.resolve(${JSON.stringify(file.fullPath)})`
+      );
+      return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
     });
     return Promise.all(entries2);
   }
@@ -668,14 +571,14 @@ async function getCollectionFiles(collection) {
   await Promise.all(
     dirs.map(async (dir) => {
       const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: path4.resolve(dir),
-        absolute: true
+        cwd: path5.resolve(dir)
       });
       for (const item of result) {
         if (!isFileSupported(item, collection)) continue;
-        files.set(item, {
-          path: path4.relative(dir, item),
-          absolutePath: item
+        const fullPath = path5.join(dir, item);
+        files.set(fullPath, {
+          path: item,
+          fullPath
         });
       }
     })
@@ -683,7 +586,7 @@ async function getCollectionFiles(collection) {
   return Array.from(files.values());
 }
 function parseMetaEntry(file, content) {
-  const extname2 = path4.extname(file);
+  const extname2 = path5.extname(file);
   try {
     if (extname2 === ".json") return JSON.parse(content);
     if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
@@ -695,13 +598,20 @@ function parseMetaEntry(file, content) {
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
-// src/map/index.ts
-var path5 = __toESM(require("path"), 1);
+// src/loaders/config/index.ts
+var import_node_path4 = __toESM(require("path"), 1);
+function findConfigFile() {
+  return import_node_path4.default.resolve("source.config.ts");
+}
+
+// src/next/map/index.ts
+var path7 = __toESM(require("path"), 1);
 var fs3 = __toESM(require("fs/promises"), 1);
+init_load();
 async function start(dev, configPath, outDir) {
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, outDir, configHash, true);
-  const outPath = path5.resolve(outDir, `index.ts`);
+  const outPath = path7.resolve(outDir, `index.ts`);
   async function updateMapFile() {
     const start2 = performance.now();
     try {
@@ -732,14 +642,14 @@ async function start(dev, configPath, outDir) {
     });
     instance.on("all", (event, file) => {
       if (typeof file !== "string") return;
-      const absolutePath = path5.resolve(file);
+      const absolutePath = path7.resolve(file);
       const onUpdate = async () => {
         const isConfigFile = absolutePath === configPath;
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfig(configPath, outDir, configHash, true);
         }
-        if (event === "change") fileCache.removeCache(absolutePath);
+        if (event === "change") removeFileCache(absolutePath);
         await updateMapFile();
       };
       void onUpdate();
@@ -825,11 +735,11 @@ function createMDX({
 // src/next/index.ts
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
   const config = await loadConfig(configPath, outDir, void 0, true);
-  const outPath = import_node_path3.default.join(outDir, "index.ts");
-  await import_promises.default.rm(outDir, { recursive: true });
-  await import_promises.default.mkdir(outDir, { recursive: true });
+  const outPath = import_node_path5.default.join(outDir, "index.ts");
+  await import_promises2.default.rm(outDir, { recursive: true });
+  await import_promises2.default.mkdir(outDir, { recursive: true });
   const hash = await getConfigHash(configPath);
-  await import_promises.default.writeFile(
+  await import_promises2.default.writeFile(
     outPath,
     await generateJS(configPath, config, { relativeTo: outDir }, hash)
   );