fumadocs-mdx 11.5.2 → 11.5.4

package/dist/next/index.cjs

@@ -259,7 +259,7 @@ function buildConfig(config) {
 function findConfigFile() {
   return path.resolve("source.config.ts");
 }
-var cache = /* @__PURE__ */ new Map();
+var cache = null;
 async function compileConfig(configPath) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -281,9 +281,8 @@ async function compileConfig(configPath) {
   }
 }
 async function loadConfig(configPath, hash, build = false) {
-  const cached = cache.get(configPath);
-  if (cached && cached.hash === hash) {
-    return await cached.config;
+  if (cache && cache.hash === hash) {
+    return await cache.config;
   }
   if (build) await compileConfig(configPath);
   const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
@@ -295,7 +294,7 @@ async function loadConfig(configPath, hash, build = false) {
     if (err !== null) throw new Error(err);
     return config2;
   });
-  cache.set(configPath, { config, hash });
+  cache = { config, hash };
   return await config;
 }
 async function getConfigHash(configPath) {
@@ -309,10 +308,11 @@ async function getConfigHash(configPath) {
 
 // src/map/index.ts
 var path3 = __toESM(require("path"), 1);
-var fs3 = __toESM(require("fs/promises"), 1);
+var fs4 = __toESM(require("fs/promises"), 1);
 
 // src/map/generate.ts
 var path2 = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs/promises"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 
 // src/utils/get-type-from-path.ts
@@ -325,8 +325,103 @@ function getTypeFromPath(path6) {
   if (metaTypes.includes(ext)) return "meta";
 }
 
+// src/utils/schema.ts
+var import_zod = require("zod");
+var metaSchema = import_zod.z.object({
+  title: import_zod.z.string().optional(),
+  pages: import_zod.z.array(import_zod.z.string()).optional(),
+  description: import_zod.z.string().optional(),
+  root: import_zod.z.boolean().optional(),
+  defaultOpen: import_zod.z.boolean().optional(),
+  icon: import_zod.z.string().optional()
+});
+var frontmatterSchema = import_zod.z.object({
+  title: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  icon: import_zod.z.string().optional(),
+  full: import_zod.z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: import_zod.z.object({}).passthrough().optional()
+});
+async function validate(schema, data, context, errorMessage) {
+  if (typeof schema === "function" && !("~standard" in schema)) {
+    schema = schema(context);
+  }
+  if ("~standard" in schema) {
+    const result = await schema["~standard"].validate(
+      data
+    );
+    if (result.issues) {
+      throw new Error(formatError(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 fileCache = {
+  read(namespace, path6) {
+    return map.get(`${namespace}.${path6}}`);
+  },
+  write(namespace, path6, data) {
+    map.set(`${namespace}.${path6}}`, data);
+  },
+  removeCache(path6) {
+    for (const key of map.keys()) {
+      const keyPath = key.slice(key.indexOf(".") + 1);
+      if (keyPath === path6) map.delete(key);
+    }
+  }
+};
+
+// 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 generateJS(configPath, config, outputPath, configHash, getFrontmatter) {
+async function readFrontmatterWithCache(file) {
+  const cached = fileCache.read("read-frontmatter", file);
+  if (cached) return cached;
+  const res = await readFrontmatter(file);
+  fileCache.write("read-frontmatter", file, res);
+  return res;
+}
+async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path2.dirname(outputPath);
   let asyncInit = false;
   const lines = [
@@ -346,7 +441,27 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
   async function getEntries(collectionName, collection, files) {
     const items = files.map(async (file, i) => {
       config._runtime.files.set(file.absolutePath, collectionName);
-      const importId = `${collectionName}_${collection.type}_${i}`;
+      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({
           type: "namespace",
@@ -372,10 +487,9 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
-      const frontmatter = await getFrontmatter(file.absolutePath);
       return JSON.stringify({
         info: file,
-        data: frontmatter
+        data: await readFrontmatterWithCache(file.absolutePath)
       });
     });
     return Promise.all(entries2);
@@ -384,19 +498,16 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
     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(
+        ", "
+      );
       if (collection.docs.async) {
         const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
-        const metaEntries2 = (await getEntries(k, collection.meta, metas)).join(
-          ", "
-        );
-        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries2}], "${k}", _sourceConfig)`;
+        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
       const docsEntries = (await getEntries(k, collection.docs, docs)).join(
         ", "
       );
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
-        ", "
-      );
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
@@ -457,72 +568,23 @@ function toImportPath(file, dir) {
   return importPath.replaceAll(path2.sep, "/");
 }
 
-// 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/index.ts
 async function start(dev, configPath, outDir2) {
-  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 });
+  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 });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path3.resolve(outDir2, `index.ts`);
-  const frontmatterCache = /* @__PURE__ */ new Map();
-  let hookUpdate = false;
-  async function readFrontmatterWithCache(file) {
-    hookUpdate = true;
-    const cached = frontmatterCache.get(file);
-    if (cached) return cached;
-    const res = await readFrontmatter(file);
-    frontmatterCache.set(file, res);
-    return res;
-  }
   async function updateMapFile() {
-    await fs3.writeFile(
+    console.time(`[MDX] update map file`);
+    await fs4.writeFile(
       outPath,
-      await generateJS(
-        configPath,
-        config,
-        outPath,
-        configHash,
-        readFrontmatterWithCache
-      )
+      await generateJS(configPath, config, outPath, configHash)
     );
+    console.timeEnd(`[MDX] update map file`);
   }
-  console.time(`[MDX] initialize map file`);
   await updateMapFile();
-  console.timeEnd(`[MDX] initialize map file`);
   if (dev) {
     const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
     const instance = watcher2(configPath, config);
@@ -531,17 +593,15 @@ async function start(dev, configPath, outDir2) {
     });
     instance.on("all", (event, file) => {
       if (typeof file !== "string") return;
+      const absolutePath = path3.resolve(file);
       const onUpdate = async () => {
-        const isConfigFile = path3.resolve(file) === configPath;
+        const isConfigFile = absolutePath === configPath;
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfig(configPath, configHash, true);
         }
-        if (isConfigFile || event !== "change" || hookUpdate) {
-          if (event === "change") frontmatterCache.delete(file);
-          await updateMapFile();
-          console.log("[MDX] Updated map file");
-        }
+        if (event === "change") fileCache.removeCache(absolutePath);
+        await updateMapFile();
       };
       void onUpdate();
     });
@@ -615,20 +675,19 @@ function createMDX({
 
 // src/postinstall.ts
 var path5 = __toESM(require("path"), 1);
-var fs4 = __toESM(require("fs"), 1);
+var fs5 = __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);
-  fs4.mkdirSync(path5.dirname(jsOut), { recursive: true });
-  fs4.writeFileSync(
+  fs5.mkdirSync(path5.dirname(jsOut), { recursive: true });
+  fs5.writeFileSync(
     jsOut,
     await generateJS(
       configPath,
       config,
       path5.resolve(".source/index.ts"),
-      hash,
-      readFrontmatter
+      hash
     )
   );
   console.log("[MDX] types generated");

package/dist/next/index.js

@@ -2,7 +2,10 @@ import {
   findConfigFile,
   getConfigHash,
   loadConfig
-} from "../chunk-USWGH3VH.js";
+} from "../chunk-2FUWXPXA.js";
+import {
+  validate
+} from "../chunk-KGLACICA.js";
 import "../chunk-6ZVE73IT.js";
 
 // src/next/create.ts
@@ -10,10 +13,11 @@ import path3 from "node:path";
 
 // src/map/index.ts
 import * as path2 from "node:path";
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 
 // src/map/generate.ts
 import * as path from "node:path";
+import * as fs2 from "node:fs/promises";
 import fg from "fast-glob";
 
 // src/utils/get-type-from-path.ts
@@ -26,8 +30,65 @@ function getTypeFromPath(path5) {
   if (metaTypes.includes(ext)) return "meta";
 }
 
+// src/map/file-cache.ts
+var map = /* @__PURE__ */ new Map();
+var fileCache = {
+  read(namespace, path5) {
+    return map.get(`${namespace}.${path5}}`);
+  },
+  write(namespace, path5, data) {
+    map.set(`${namespace}.${path5}}`, data);
+  },
+  removeCache(path5) {
+    for (const key of map.keys()) {
+      const keyPath = key.slice(key.indexOf(".") + 1);
+      if (keyPath === path5) map.delete(key);
+    }
+  }
+};
+
+// 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 generateJS(configPath, config, outputPath, configHash, getFrontmatter) {
+async function readFrontmatterWithCache(file) {
+  const cached = fileCache.read("read-frontmatter", file);
+  if (cached) return cached;
+  const res = await readFrontmatter(file);
+  fileCache.write("read-frontmatter", file, res);
+  return res;
+}
+async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path.dirname(outputPath);
   let asyncInit = false;
   const lines = [
@@ -47,7 +108,27 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
   async function getEntries(collectionName, collection, files) {
     const items = files.map(async (file, i) => {
       config._runtime.files.set(file.absolutePath, collectionName);
-      const importId = `${collectionName}_${collection.type}_${i}`;
+      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({
           type: "namespace",
@@ -73,10 +154,9 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
-      const frontmatter = await getFrontmatter(file.absolutePath);
       return JSON.stringify({
         info: file,
-        data: frontmatter
+        data: await readFrontmatterWithCache(file.absolutePath)
       });
     });
     return Promise.all(entries2);
@@ -85,19 +165,16 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
     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(
+        ", "
+      );
       if (collection.docs.async) {
         const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
-        const metaEntries2 = (await getEntries(k, collection.meta, metas)).join(
-          ", "
-        );
-        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries2}], "${k}", _sourceConfig)`;
+        return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
       const docsEntries = (await getEntries(k, collection.docs, docs)).join(
         ", "
       );
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
-        ", "
-      );
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
@@ -158,72 +235,23 @@ function toImportPath(file, dir) {
   return importPath.replaceAll(path.sep, "/");
 }
 
-// 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/index.ts
 async function start(dev, configPath, outDir2) {
-  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 });
+  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 });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path2.resolve(outDir2, `index.ts`);
-  const frontmatterCache = /* @__PURE__ */ new Map();
-  let hookUpdate = false;
-  async function readFrontmatterWithCache(file) {
-    hookUpdate = true;
-    const cached = frontmatterCache.get(file);
-    if (cached) return cached;
-    const res = await readFrontmatter(file);
-    frontmatterCache.set(file, res);
-    return res;
-  }
   async function updateMapFile() {
-    await fs2.writeFile(
+    console.time(`[MDX] update map file`);
+    await fs3.writeFile(
       outPath,
-      await generateJS(
-        configPath,
-        config,
-        outPath,
-        configHash,
-        readFrontmatterWithCache
-      )
+      await generateJS(configPath, config, outPath, configHash)
     );
+    console.timeEnd(`[MDX] update map file`);
   }
-  console.time(`[MDX] initialize map file`);
   await updateMapFile();
-  console.timeEnd(`[MDX] initialize map file`);
   if (dev) {
     const { watcher } = await import("../watcher-IAZDSTU7.js");
     const instance = watcher(configPath, config);
@@ -232,17 +260,15 @@ async function start(dev, configPath, outDir2) {
     });
     instance.on("all", (event, file) => {
       if (typeof file !== "string") return;
+      const absolutePath = path2.resolve(file);
       const onUpdate = async () => {
-        const isConfigFile = path2.resolve(file) === configPath;
+        const isConfigFile = absolutePath === configPath;
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfig(configPath, configHash, true);
         }
-        if (isConfigFile || event !== "change" || hookUpdate) {
-          if (event === "change") frontmatterCache.delete(file);
-          await updateMapFile();
-          console.log("[MDX] Updated map file");
-        }
+        if (event === "change") fileCache.removeCache(absolutePath);
+        await updateMapFile();
       };
       void onUpdate();
     });
@@ -316,20 +342,19 @@ function createMDX({
 
 // src/postinstall.ts
 import * as path4 from "node:path";
-import * as fs3 from "node:fs";
+import * as fs4 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);
-  fs3.mkdirSync(path4.dirname(jsOut), { recursive: true });
-  fs3.writeFileSync(
+  fs4.mkdirSync(path4.dirname(jsOut), { recursive: true });
+  fs4.writeFileSync(
     jsOut,
     await generateJS(
       configPath,
       config,
       path4.resolve(".source/index.ts"),
-      hash,
-      readFrontmatter
+      hash
     )
   );
   console.log("[MDX] types generated");

package/dist/runtime/async.cjs

@@ -234,7 +234,7 @@ var _runtime = {
   meta(files) {
     return files.map((file) => {
       return {
-        ...file.data.default,
+        ...file.data,
         _file: file.info
       };
     });

package/dist/runtime/async.d.cts

@@ -1,13 +1,13 @@
-import { L as LoadedConfig, b as RuntimeAsync } from '../types-C214DTNR.cjs';
-import '../define-B4aTedg-.cjs';
+import { L as LoadedConfig, b as RuntimeAsync } from '../types-8ecOBKxa.cjs';
+import '../define-DxwgTgV6.cjs';
 import '@mdx-js/mdx';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';
 import 'fumadocs-core/server';
 import 'unified';
 import 'react';
-import '@standard-schema/spec';
 import 'zod';
+import '@standard-schema/spec';
 import 'fumadocs-core/source';
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];

package/dist/runtime/async.d.ts

@@ -1,13 +1,13 @@
-import { L as LoadedConfig, b as RuntimeAsync } from '../types-qPYo6njm.js';
-import '../define-B4aTedg-.js';
+import { L as LoadedConfig, b as RuntimeAsync } from '../types-BQ1vyPw8.js';
+import '../define-DxwgTgV6.js';
 import '@mdx-js/mdx';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';
 import 'fumadocs-core/server';
 import 'unified';
 import 'react';
-import '@standard-schema/spec';
 import 'zod';
+import '@standard-schema/spec';
 import 'fumadocs-core/source';
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];

package/dist/runtime/async.js

@@ -1,7 +1,7 @@
 import {
   _runtime,
   createMDXSource
-} from "../chunk-3PXNPJQ2.js";
+} from "../chunk-IZURUUPO.js";
 import {
   remarkInclude
 } from "../chunk-PY2KKTR2.js";