fumadocs-mdx 12.0.0 → 12.0.2

package/dist/next/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,56 +111,12 @@ 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/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();
@@ -210,12 +166,13 @@ function buildConfig(config) {
     }
   };
 }
+var init_build = __esm({
+  "src/config/build.ts"() {
+    "use strict";
+  }
+});
 
-// src/utils/config.ts
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
-var cache = null;
+// src/loaders/config/load.ts
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -258,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
@@ -306,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) {
@@ -339,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
       }
@@ -369,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}`;
@@ -384,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";
@@ -395,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
@@ -423,19 +434,14 @@ 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 = [
     getImportCode({
       type: "named",
       names: ["_runtime"],
-      specifier: "fumadocs-mdx"
+      specifier: "fumadocs-mdx/runtime/next"
     }),
     getImportCode({
       type: "namespace",
@@ -492,14 +498,18 @@ 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.fullPath).catch(() => "")
-      );
+      const content = await readFileWithCache(file.fullPath).catch(() => "");
+      const parsed = fumaMatter(content);
       let data = parsed.data;
       if (collection.schema) {
         data = await validate(
@@ -513,12 +523,15 @@ async function generateJS(configPath, config, importPath, configHash = false) {
       if (config.global?.lastModifiedTime === "git") {
         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);
   }
@@ -558,11 +571,11 @@ async function getCollectionFiles(collection) {
   await Promise.all(
     dirs.map(async (dir) => {
       const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: path4.resolve(dir)
+        cwd: path5.resolve(dir)
       });
       for (const item of result) {
         if (!isFileSupported(item, collection)) continue;
-        const fullPath = path4.join(dir, item);
+        const fullPath = path5.join(dir, item);
         files.set(fullPath, {
           path: item,
           fullPath
@@ -573,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);
@@ -585,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 {
@@ -622,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();
@@ -715,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)
   );

package/dist/next/index.js

@@ -1,67 +1,46 @@
+import {
+  readFileWithCache,
+  removeFileCache
+} from "../chunk-ADR6R7HM.js";
 import {
   getGlobPatterns,
   getImportCode,
   isFileSupported,
   toImportPath
 } from "../chunk-6Y5JDZHD.js";
+import {
+  getConfigHash,
+  loadConfig
+} from "../chunk-LGYVNESJ.js";
+import "../chunk-U4MQ44TS.js";
 import {
   ValidationError,
   getGitTimestamp,
   validate
 } from "../chunk-IQAEAI4P.js";
 import {
-  findConfigFile,
-  getConfigHash,
-  loadConfig
-} from "../chunk-POXTQZ4D.js";
-import "../chunk-YC25YEBF.js";
+  findConfigFile
+} from "../chunk-XMFLD5J6.js";
 import {
   fumaMatter
 } from "../chunk-VWJKRQZR.js";
 
 // src/next/index.ts
 import path3 from "path";
-import fs3 from "fs/promises";
+import fs2 from "fs/promises";
 
-// src/map/generate.ts
+// src/next/map/generate.ts
 import * as path from "path";
-import * as fs from "fs/promises";
+import { createHash } from "crypto";
 import { glob } from "tinyglobby";
-
-// src/map/file-cache.ts
-import { LRUCache } from "lru-cache";
-var map = new LRUCache({
-  max: 200
-});
-var fileCache = {
-  read(namespace, path4) {
-    return map.get(`${namespace}.${path4}`);
-  },
-  write(namespace, path4, data) {
-    map.set(`${namespace}.${path4}`, data);
-  },
-  removeCache(path4) {
-    for (const key of map.keys()) {
-      const keyPath = key.slice(key.indexOf(".") + 1);
-      if (keyPath === path4) map.delete(key);
-    }
-  }
-};
-
-// src/map/generate.ts
 import { load } from "js-yaml";
-async function readFileWithCache(file) {
-  const cached = fileCache.read("read-file", file);
-  if (cached) return cached;
-  return (await fs.readFile(file)).toString();
-}
 async function generateJS(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
     getImportCode({
       type: "named",
       names: ["_runtime"],
-      specifier: "fumadocs-mdx"
+      specifier: "fumadocs-mdx/runtime/next"
     }),
     getImportCode({
       type: "namespace",
@@ -118,14 +97,18 @@ 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.fullPath).catch(() => "")
-      );
+      const content = await readFileWithCache(file.fullPath).catch(() => "");
+      const parsed = fumaMatter(content);
       let data = parsed.data;
       if (collection.schema) {
         data = await validate(
@@ -139,12 +122,15 @@ async function generateJS(configPath, config, importPath, configHash = false) {
       if (config.global?.lastModifiedTime === "git") {
         lastModified = await getGitTimestamp(file.fullPath);
       }
-      return JSON.stringify({
-        info: file,
-        lastModified,
-        data,
-        content: { body: parsed.content, matter: parsed.matter }
-      });
+      const hash = 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);
   }
@@ -211,9 +197,9 @@ function parseMetaEntry(file, content) {
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
-// src/map/index.ts
+// src/next/map/index.ts
 import * as path2 from "path";
-import * as fs2 from "fs/promises";
+import * as fs from "fs/promises";
 async function start(dev, configPath, outDir) {
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, outDir, configHash, true);
@@ -221,7 +207,7 @@ async function start(dev, configPath, outDir) {
   async function updateMapFile() {
     const start2 = performance.now();
     try {
-      await fs2.writeFile(
+      await fs.writeFile(
         outPath,
         await generateJS(
           configPath,
@@ -241,7 +227,7 @@ async function start(dev, configPath, outDir) {
   }
   await updateMapFile();
   if (dev) {
-    const { watcher } = await import("../watcher-4NDMOH4R.js");
+    const { watcher } = await import("../watcher-HGOH3APP.js");
     const instance = watcher(configPath, config, [outPath]);
     instance.on("ready", () => {
       console.log("[MDX] started dev server");
@@ -255,7 +241,7 @@ async function start(dev, configPath, outDir) {
           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();
@@ -342,10 +328,10 @@ function createMDX({
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
   const config = await loadConfig(configPath, outDir, void 0, true);
   const outPath = path3.join(outDir, "index.ts");
-  await fs3.rm(outDir, { recursive: true });
-  await fs3.mkdir(outDir, { recursive: true });
+  await fs2.rm(outDir, { recursive: true });
+  await fs2.mkdir(outDir, { recursive: true });
   const hash = await getConfigHash(configPath);
-  await fs3.writeFile(
+  await fs2.writeFile(
     outPath,
     await generateJS(configPath, config, { relativeTo: outDir }, hash)
   );