fumadocs-mdx 11.5.7 → 11.6.0

package/dist/next/index.cjs

@@ -110,10 +110,7 @@ function buildConfig(config) {
     null,
     {
       global: globalConfig,
-      collections,
-      _runtime: {
-        files: /* @__PURE__ */ new Map()
-      }
+      collections
     }
   ];
 }
@@ -170,11 +167,11 @@ async function getConfigHash(configPath) {
 
 // src/map/index.ts
 var path3 = __toESM(require("path"), 1);
-var fs4 = __toESM(require("fs/promises"), 1);
+var fs3 = __toESM(require("fs/promises"), 1);
 
 // src/map/generate.ts
 var path2 = __toESM(require("path"), 1);
-var fs3 = __toESM(require("fs/promises"), 1);
+var fs2 = __toESM(require("fs/promises"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 
 // src/utils/get-type-from-path.ts
@@ -189,6 +186,7 @@ function getTypeFromPath(path6) {
 
 // src/utils/schema.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(),
@@ -205,6 +203,28 @@ var frontmatterSchema = import_zod.z.object({
   // Fumadocs OpenAPI generated
   _openapi: import_zod.z.object({}).passthrough().optional()
 });
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+  print() {
+    console.error(
+      [
+        `[MDX] ${this.message}:`,
+        ...this.issues.map(
+          (issue) => import_picocolors.default.redBright(
+            `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+          )
+        )
+      ].join("\n")
+    );
+  }
+  toString() {
+    return `${this.message}:
+${this.issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
+  }
+};
 async function validate(schema, data, context, errorMessage) {
   if (typeof schema === "function" && !("~standard" in schema)) {
     schema = schema(context);
@@ -214,19 +234,18 @@ async function validate(schema, data, context, errorMessage) {
       data
     );
     if (result.issues) {
-      throw new Error(formatError(errorMessage, result.issues));
+      throw new ValidationError(errorMessage, result.issues);
     }
     return result.value;
   }
   return data;
 }
-function formatError(message, issues) {
-  return `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
-}
 
 // src/map/file-cache.ts
-var map = /* @__PURE__ */ new Map();
+var import_lru_cache = require("lru-cache");
+var map = new import_lru_cache.LRUCache({
+  max: 200
+});
 var fileCache = {
   read(namespace, path6) {
     return map.get(`${namespace}.${path6}`);
@@ -242,46 +261,12 @@ var fileCache = {
   }
 };
 
-// src/utils/read-frontmatter.ts
-var fs2 = __toESM(require("fs"), 1);
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-async function readFrontmatter(file) {
-  const readStream = fs2.createReadStream(file, {
-    highWaterMark: 250
-  });
-  return new Promise((res, rej) => {
-    let idx = 0;
-    let str = "";
-    readStream.on("data", (_chunk) => {
-      const chunk = _chunk.toString();
-      if (idx === 0 && !chunk.startsWith("---")) {
-        res({});
-        readStream.close();
-        return;
-      }
-      str += chunk;
-      idx++;
-      if (str.includes("\n---")) {
-        res(
-          (0, import_gray_matter.default)({
-            content: str
-          }).data
-        );
-        readStream.close();
-      }
-    });
-    readStream.on("end", () => res({}));
-    readStream.on("error", (e) => rej(e));
-  });
-}
-
 // src/map/generate.ts
-async function readFrontmatterWithCache(file) {
-  const cached = fileCache.read("read-frontmatter", file);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+async function readFileWithCache(file) {
+  const cached = fileCache.read("read-file", file);
   if (cached) return cached;
-  const res = await readFrontmatter(file);
-  fileCache.write("read-frontmatter", file, res);
-  return res;
+  return (await fs2.readFile(file)).toString();
 }
 async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path2.dirname(outputPath);
@@ -298,31 +283,9 @@ async function generateJS(configPath, config, outputPath, configHash) {
       name: "_source"
     })
   ];
-  config._runtime.files.clear();
   const entries = Array.from(config.collections.entries());
-  async function getEntries(collectionName, collection, files) {
+  async function getDocEntries(collectionName, files) {
     const items = files.map(async (file, i) => {
-      config._runtime.files.set(file.absolutePath, collectionName);
-      if (collection.type === "meta") {
-        const cached = fileCache.read("generate-js", file.absolutePath);
-        if (cached) return cached;
-        const source = (await fs3.readFile(file.absolutePath)).toString();
-        let data = JSON.parse(source);
-        if (collection?.schema) {
-          data = await validate(
-            collection.schema,
-            data,
-            {
-              source,
-              path: file.absolutePath
-            },
-            `invalid data in ${file.absolutePath}:`
-          );
-        }
-        const entry = `{ info: ${JSON.stringify(file)}, data: ${JSON.stringify(data)} }`;
-        fileCache.write("generate-js", file.absolutePath, entry);
-        return entry;
-      }
       const importId = `${collectionName}_${i}`;
       lines.unshift(
         getImportCode({
@@ -335,7 +298,29 @@ async function generateJS(configPath, config, outputPath, configHash) {
     });
     return Promise.all(items);
   }
-  async function getAsyncEntries(files) {
+  async function getMetaEntries(collection, files) {
+    const items = files.map(async (file) => {
+      const source = await readFileWithCache(file.absolutePath).catch(() => "");
+      let data = source.length === 0 ? {} : JSON.parse(source);
+      if (collection?.schema) {
+        data = await validate(
+          collection.schema,
+          data,
+          {
+            source,
+            path: file.absolutePath
+          },
+          `invalid data in ${file.absolutePath}`
+        );
+      }
+      return JSON.stringify({
+        info: file,
+        data
+      });
+    });
+    return Promise.all(items);
+  }
+  async function getAsyncEntries(collection, files) {
     if (!asyncInit) {
       lines.unshift(
         getImportCode({
@@ -349,9 +334,21 @@ async function generateJS(configPath, config, outputPath, configHash) {
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
+      const parsed = (0, import_gray_matter.default)(
+        await readFileWithCache(file.absolutePath).catch(() => "")
+      );
+      if (collection.schema) {
+        parsed.data = await validate(
+          collection.schema,
+          parsed.data,
+          { path: file.absolutePath, source: parsed.content },
+          `invalid frontmatter in ${file.absolutePath}`
+        );
+      }
       return JSON.stringify({
         info: file,
-        data: await readFrontmatterWithCache(file.absolutePath)
+        data: parsed.data,
+        content: parsed.content
       });
     });
     return Promise.all(entries2);
@@ -360,23 +357,23 @@ async function generateJS(configPath, config, outputPath, configHash) {
     if (collection.type === "docs") {
       const docs = await getCollectionFiles(collection.docs);
       const metas = await getCollectionFiles(collection.meta);
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
+      const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
       if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
+        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
+          ", "
+        );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getEntries(k, collection.docs, docs)).join(
-        ", "
-      );
+      const docsEntries = (await getDocEntries(k, docs)).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
     if (collection.type === "doc" && collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(files)).join(", ")}], "${k}", _sourceConfig)`;
+      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getEntries(k, collection, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -432,18 +429,26 @@ function toImportPath(file, dir) {
 
 // src/map/index.ts
 async function start(dev, configPath, outDir2) {
-  void fs4.rm(path3.resolve(outDir2, `index.js`), { force: true });
-  void fs4.rm(path3.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs4.mkdir(outDir2, { recursive: true });
+  void fs3.rm(path3.resolve(outDir2, `index.js`), { force: true });
+  void fs3.rm(path3.resolve(outDir2, `index.d.ts`), { force: true });
+  await fs3.mkdir(outDir2, { recursive: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path3.resolve(outDir2, `index.ts`);
   async function updateMapFile() {
     console.time(`[MDX] update map file`);
-    await fs4.writeFile(
-      outPath,
-      await generateJS(configPath, config, outPath, configHash)
-    );
+    try {
+      await fs3.writeFile(
+        outPath,
+        await generateJS(configPath, config, outPath, configHash)
+      );
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        err.print();
+      } else {
+        console.error(err);
+      }
+    }
     console.timeEnd(`[MDX] update map file`);
   }
   await updateMapFile();
@@ -494,22 +499,19 @@ function createMDX({
     };
     return {
       ...nextConfig,
-      experimental: {
-        ...nextConfig.experimental,
-        turbo: {
-          ...nextConfig.experimental?.turbo,
-          rules: {
-            ...nextConfig.experimental?.turbo?.rules,
-            // @ts-expect-error -- safe types
-            "*.{md,mdx}": {
-              loaders: [
-                {
-                  loader: "fumadocs-mdx/loader-mdx",
-                  options: mdxLoaderOptions
-                }
-              ],
-              as: "*.js"
-            }
+      turbopack: {
+        ...nextConfig?.turbopack,
+        rules: {
+          ...nextConfig?.turbopack?.rules,
+          // @ts-expect-error -- safe
+          "*.{md,mdx}": {
+            loaders: [
+              {
+                loader: "fumadocs-mdx/loader-mdx",
+                options: mdxLoaderOptions
+              }
+            ],
+            as: "*.js"
           }
         }
       },
@@ -537,13 +539,13 @@ function createMDX({
 
 // src/postinstall.ts
 var path5 = __toESM(require("path"), 1);
-var fs5 = __toESM(require("fs"), 1);
+var fs4 = __toESM(require("fs"), 1);
 async function postInstall(configPath = findConfigFile()) {
   const jsOut = path5.resolve(".source/index.ts");
   const hash = await getConfigHash(configPath);
   const config = await loadConfig(configPath, hash, true);
-  fs5.mkdirSync(path5.dirname(jsOut), { recursive: true });
-  fs5.writeFileSync(
+  fs4.mkdirSync(path5.dirname(jsOut), { recursive: true });
+  fs4.writeFileSync(
     jsOut,
     await generateJS(
       configPath,

package/dist/next/index.js

@@ -2,22 +2,23 @@ import {
   findConfigFile,
   getConfigHash,
   loadConfig
-} from "../chunk-R6U7CJLB.js";
+} from "../chunk-HFLDWPJA.js";
+import "../chunk-DRVUBK5B.js";
 import {
+  ValidationError,
   validate
-} from "../chunk-KGLACICA.js";
-import "../chunk-SLCPEEMF.js";
+} from "../chunk-2ZOW45YZ.js";
 
 // src/next/create.ts
 import path3 from "node:path";
 
 // src/map/index.ts
 import * as path2 from "node:path";
-import * as fs3 from "node:fs/promises";
+import * as fs2 from "node:fs/promises";
 
 // src/map/generate.ts
 import * as path from "node:path";
-import * as fs2 from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import fg from "fast-glob";
 
 // src/utils/get-type-from-path.ts
@@ -31,7 +32,10 @@ function getTypeFromPath(path5) {
 }
 
 // src/map/file-cache.ts
-var map = /* @__PURE__ */ new Map();
+import { LRUCache } from "lru-cache";
+var map = new LRUCache({
+  max: 200
+});
 var fileCache = {
   read(namespace, path5) {
     return map.get(`${namespace}.${path5}`);
@@ -47,46 +51,12 @@ var fileCache = {
   }
 };
 
-// src/utils/read-frontmatter.ts
-import * as fs from "node:fs";
-import grayMatter from "gray-matter";
-async function readFrontmatter(file) {
-  const readStream = fs.createReadStream(file, {
-    highWaterMark: 250
-  });
-  return new Promise((res, rej) => {
-    let idx = 0;
-    let str = "";
-    readStream.on("data", (_chunk) => {
-      const chunk = _chunk.toString();
-      if (idx === 0 && !chunk.startsWith("---")) {
-        res({});
-        readStream.close();
-        return;
-      }
-      str += chunk;
-      idx++;
-      if (str.includes("\n---")) {
-        res(
-          grayMatter({
-            content: str
-          }).data
-        );
-        readStream.close();
-      }
-    });
-    readStream.on("end", () => res({}));
-    readStream.on("error", (e) => rej(e));
-  });
-}
-
 // src/map/generate.ts
-async function readFrontmatterWithCache(file) {
-  const cached = fileCache.read("read-frontmatter", file);
+import matter from "gray-matter";
+async function readFileWithCache(file) {
+  const cached = fileCache.read("read-file", file);
   if (cached) return cached;
-  const res = await readFrontmatter(file);
-  fileCache.write("read-frontmatter", file, res);
-  return res;
+  return (await fs.readFile(file)).toString();
 }
 async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path.dirname(outputPath);
@@ -103,31 +73,9 @@ async function generateJS(configPath, config, outputPath, configHash) {
       name: "_source"
     })
   ];
-  config._runtime.files.clear();
   const entries = Array.from(config.collections.entries());
-  async function getEntries(collectionName, collection, files) {
+  async function getDocEntries(collectionName, files) {
     const items = files.map(async (file, i) => {
-      config._runtime.files.set(file.absolutePath, collectionName);
-      if (collection.type === "meta") {
-        const cached = fileCache.read("generate-js", file.absolutePath);
-        if (cached) return cached;
-        const source = (await fs2.readFile(file.absolutePath)).toString();
-        let data = JSON.parse(source);
-        if (collection?.schema) {
-          data = await validate(
-            collection.schema,
-            data,
-            {
-              source,
-              path: file.absolutePath
-            },
-            `invalid data in ${file.absolutePath}:`
-          );
-        }
-        const entry = `{ info: ${JSON.stringify(file)}, data: ${JSON.stringify(data)} }`;
-        fileCache.write("generate-js", file.absolutePath, entry);
-        return entry;
-      }
       const importId = `${collectionName}_${i}`;
       lines.unshift(
         getImportCode({
@@ -140,7 +88,29 @@ async function generateJS(configPath, config, outputPath, configHash) {
     });
     return Promise.all(items);
   }
-  async function getAsyncEntries(files) {
+  async function getMetaEntries(collection, files) {
+    const items = files.map(async (file) => {
+      const source = await readFileWithCache(file.absolutePath).catch(() => "");
+      let data = source.length === 0 ? {} : JSON.parse(source);
+      if (collection?.schema) {
+        data = await validate(
+          collection.schema,
+          data,
+          {
+            source,
+            path: file.absolutePath
+          },
+          `invalid data in ${file.absolutePath}`
+        );
+      }
+      return JSON.stringify({
+        info: file,
+        data
+      });
+    });
+    return Promise.all(items);
+  }
+  async function getAsyncEntries(collection, files) {
     if (!asyncInit) {
       lines.unshift(
         getImportCode({
@@ -154,9 +124,21 @@ async function generateJS(configPath, config, outputPath, configHash) {
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
+      const parsed = matter(
+        await readFileWithCache(file.absolutePath).catch(() => "")
+      );
+      if (collection.schema) {
+        parsed.data = await validate(
+          collection.schema,
+          parsed.data,
+          { path: file.absolutePath, source: parsed.content },
+          `invalid frontmatter in ${file.absolutePath}`
+        );
+      }
       return JSON.stringify({
         info: file,
-        data: await readFrontmatterWithCache(file.absolutePath)
+        data: parsed.data,
+        content: parsed.content
       });
     });
     return Promise.all(entries2);
@@ -165,23 +147,23 @@ async function generateJS(configPath, config, outputPath, configHash) {
     if (collection.type === "docs") {
       const docs = await getCollectionFiles(collection.docs);
       const metas = await getCollectionFiles(collection.meta);
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
+      const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
       if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
+        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
+          ", "
+        );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getEntries(k, collection.docs, docs)).join(
-        ", "
-      );
+      const docsEntries = (await getDocEntries(k, docs)).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
     if (collection.type === "doc" && collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(files)).join(", ")}], "${k}", _sourceConfig)`;
+      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getEntries(k, collection, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -237,18 +219,26 @@ function toImportPath(file, dir) {
 
 // src/map/index.ts
 async function start(dev, configPath, outDir2) {
-  void fs3.rm(path2.resolve(outDir2, `index.js`), { force: true });
-  void fs3.rm(path2.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs3.mkdir(outDir2, { recursive: true });
+  void fs2.rm(path2.resolve(outDir2, `index.js`), { force: true });
+  void fs2.rm(path2.resolve(outDir2, `index.d.ts`), { force: true });
+  await fs2.mkdir(outDir2, { recursive: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path2.resolve(outDir2, `index.ts`);
   async function updateMapFile() {
     console.time(`[MDX] update map file`);
-    await fs3.writeFile(
-      outPath,
-      await generateJS(configPath, config, outPath, configHash)
-    );
+    try {
+      await fs2.writeFile(
+        outPath,
+        await generateJS(configPath, config, outPath, configHash)
+      );
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        err.print();
+      } else {
+        console.error(err);
+      }
+    }
     console.timeEnd(`[MDX] update map file`);
   }
   await updateMapFile();
@@ -299,22 +289,19 @@ function createMDX({
     };
     return {
       ...nextConfig,
-      experimental: {
-        ...nextConfig.experimental,
-        turbo: {
-          ...nextConfig.experimental?.turbo,
-          rules: {
-            ...nextConfig.experimental?.turbo?.rules,
-            // @ts-expect-error -- safe types
-            "*.{md,mdx}": {
-              loaders: [
-                {
-                  loader: "fumadocs-mdx/loader-mdx",
-                  options: mdxLoaderOptions
-                }
-              ],
-              as: "*.js"
-            }
+      turbopack: {
+        ...nextConfig?.turbopack,
+        rules: {
+          ...nextConfig?.turbopack?.rules,
+          // @ts-expect-error -- safe
+          "*.{md,mdx}": {
+            loaders: [
+              {
+                loader: "fumadocs-mdx/loader-mdx",
+                options: mdxLoaderOptions
+              }
+            ],
+            as: "*.js"
           }
         }
       },
@@ -342,13 +329,13 @@ function createMDX({
 
 // src/postinstall.ts
 import * as path4 from "node:path";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 async function postInstall(configPath = findConfigFile()) {
   const jsOut = path4.resolve(".source/index.ts");
   const hash = await getConfigHash(configPath);
   const config = await loadConfig(configPath, hash, true);
-  fs4.mkdirSync(path4.dirname(jsOut), { recursive: true });
-  fs4.writeFileSync(
+  fs3.mkdirSync(path4.dirname(jsOut), { recursive: true });
+  fs3.writeFileSync(
     jsOut,
     await generateJS(
       configPath,