fumadocs-mdx 12.0.0 → 12.0.1

package/dist/bin.cjs

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/mdx/preset.ts
+// src/loaders/mdx/preset.ts
 var preset_exports = {};
 __export(preset_exports, {
   getDefaultMDXOptions: () => getDefaultMDXOptions
@@ -111,7 +111,7 @@ 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);
   }
@@ -172,10 +172,7 @@ var init_build = __esm({
   }
 });
 
-// src/utils/config.ts
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
+// src/loaders/config/load.ts
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -219,8 +216,8 @@ async function getConfigHash(configPath) {
   throw new Error("Cannot find config file");
 }
 var fs, path, import_node_url, cache;
-var init_config = __esm({
-  "src/utils/config.ts"() {
+var init_load = __esm({
+  "src/loaders/config/load.ts"() {
     "use strict";
     fs = __toESM(require("fs/promises"), 1);
     path = __toESM(require("path"), 1);
@@ -274,29 +271,34 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
   }
 });
 
-// src/map/file-cache.ts
-var import_lru_cache, map, fileCache;
+// src/next/map/file-cache.ts
+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));
+}
+var import_lru_cache, import_promises, import_node_path, map;
 var init_file_cache = __esm({
-  "src/map/file-cache.ts"() {
+  "src/next/map/file-cache.ts"() {
     "use strict";
     import_lru_cache = require("lru-cache");
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_node_path = __toESM(require("path"), 1);
     map = new import_lru_cache.LRUCache({
-      max: 200
+      max: 100
     });
-    fileCache = {
-      read(namespace, path8) {
-        return map.get(`${namespace}.${path8}`);
-      },
-      write(namespace, path8, data) {
-        map.set(`${namespace}.${path8}`, data);
-      },
-      removeCache(path8) {
-        for (const key of map.keys()) {
-          const keyPath = key.slice(key.indexOf(".") + 1);
-          if (keyPath === path8) map.delete(key);
-        }
-      }
-    };
   }
 });
 
@@ -307,7 +309,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
       }
@@ -319,11 +321,11 @@ async function getGitTimestamp(file) {
     return;
   }
 }
-var import_node_path, import_tinyexec, cache2;
+var import_node_path2, import_tinyexec, cache2;
 var init_git_timestamp = __esm({
   "src/utils/git-timestamp.ts"() {
     "use strict";
-    import_node_path = __toESM(require("path"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
     import_tinyexec = require("tinyexec");
     cache2 = /* @__PURE__ */ new Map();
   }
@@ -366,7 +368,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";
@@ -377,23 +379,23 @@ 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, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_node_path2;
+var import_node_path3;
 var init_import_formatter = __esm({
   "src/utils/import-formatter.ts"() {
     "use strict";
-    import_node_path2 = __toESM(require("path"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
   }
 });
 
@@ -420,12 +422,7 @@ var init_collections = __esm({
   }
 });
 
-// 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 = [
@@ -489,14 +486,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(
@@ -510,12 +511,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);
   }
@@ -555,11 +559,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
@@ -570,7 +574,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);
@@ -581,12 +585,12 @@ function parseMetaEntry(file, content) {
   }
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
-var path4, fs2, import_tinyglobby, import_js_yaml2;
+var path5, import_node_crypto, import_tinyglobby, import_js_yaml2;
 var init_generate = __esm({
-  "src/map/generate.ts"() {
+  "src/next/map/generate.ts"() {
     "use strict";
-    path4 = __toESM(require("path"), 1);
-    fs2 = __toESM(require("fs/promises"), 1);
+    path5 = __toESM(require("path"), 1);
+    import_node_crypto = require("crypto");
     import_tinyglobby = require("tinyglobby");
     init_validation();
     init_file_cache();
@@ -598,7 +602,19 @@ var init_generate = __esm({
   }
 });
 
-// src/map/watcher.ts
+// src/loaders/config/index.ts
+function findConfigFile() {
+  return import_node_path4.default.resolve("source.config.ts");
+}
+var import_node_path4;
+var init_config = __esm({
+  "src/loaders/config/index.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"), 1);
+  }
+});
+
+// src/next/map/watcher.ts
 var watcher_exports = {};
 __export(watcher_exports, {
   watcher: () => watcher
@@ -622,17 +638,17 @@ function watcher(configPath, config, ignored) {
 }
 var import_chokidar;
 var init_watcher = __esm({
-  "src/map/watcher.ts"() {
+  "src/next/map/watcher.ts"() {
     "use strict";
     import_chokidar = require("chokidar");
   }
 });
 
-// src/map/index.ts
+// src/next/map/index.ts
 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 start3 = performance.now();
     try {
@@ -663,14 +679,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();
@@ -681,13 +697,13 @@ async function start(dev, configPath, outDir) {
     });
   }
 }
-var path5, fs3;
+var path7, fs3;
 var init_map = __esm({
-  "src/map/index.ts"() {
+  "src/next/map/index.ts"() {
     "use strict";
-    path5 = __toESM(require("path"), 1);
+    path7 = __toESM(require("path"), 1);
     fs3 = __toESM(require("fs/promises"), 1);
-    init_config();
+    init_load();
     init_generate();
     init_file_cache();
     init_validation();
@@ -781,24 +797,25 @@ __export(next_exports, {
 });
 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)
   );
   console.log("[MDX] types generated");
 }
-var import_node_path3, import_promises;
+var import_node_path5, import_promises2;
 var init_next = __esm({
   "src/next/index.ts"() {
     "use strict";
-    init_config();
-    import_node_path3 = __toESM(require("path"), 1);
-    import_promises = __toESM(require("fs/promises"), 1);
+    init_load();
+    import_node_path5 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
     init_generate();
+    init_config();
     init_create();
   }
 });
@@ -918,22 +935,23 @@ async function postInstall2(configPath = findConfigFile(), outDir, addJsExtensio
   const config = await loadConfig(configPath, "node_modules", void 0, true);
   const outFile = "source.generated.ts";
   if (outDir) {
-    await import_promises2.default.mkdir(outDir, { recursive: true });
+    await import_promises3.default.mkdir(outDir, { recursive: true });
   }
-  await import_promises2.default.writeFile(
-    outDir ? import_node_path4.default.join(outDir, outFile) : outFile,
+  await import_promises3.default.writeFile(
+    outDir ? import_node_path6.default.join(outDir, outFile) : outFile,
     entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
   );
   console.log("[MDX] types generated");
 }
-var import_promises2, import_node_path4;
+var import_promises3, import_node_path6;
 var init_postinstall = __esm({
   "src/vite/postinstall.ts"() {
     "use strict";
-    init_config();
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    import_node_path4 = __toESM(require("path"), 1);
+    init_load();
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
     init_generate2();
+    init_config();
   }
 });
 

package/dist/bin.js

@@ -9,7 +9,7 @@ async function start() {
     const { postInstall } = await import("./next/index.js");
     await postInstall(...args);
   } else {
-    const { postInstall } = await import("./postinstall-U7VROOY7.js");
+    const { postInstall } = await import("./postinstall-SCSXM4IM.js");
     await postInstall(...args);
   }
 }