fumadocs-mdx 11.5.3 → 11.5.5

package/dist/next/index.cjs

@@ -30,130 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/mdx-plugins/remark-exports.ts
-function remarkMdxExport({ values }) {
-  return (tree, vfile) => {
-    for (const name of values) {
-      if (!(name in vfile.data)) return;
-      tree.children.unshift(getMdastExport(name, vfile.data[name]));
-    }
-  };
-}
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            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_estree_util_value_to_estree;
-var init_remark_exports = __esm({
-  "src/mdx-plugins/remark-exports.ts"() {
-    "use strict";
-    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, {
-  getDefaultMDXOptions: () => getDefaultMDXOptions
-});
-function pluginOption(def, options = []) {
-  const list = def(Array.isArray(options) ? options : []).filter(
-    Boolean
-  );
-  if (typeof options === "function") {
-    return options(list);
-  }
-  return list;
-}
-function getDefaultMDXOptions({
-  valueToExport = [],
-  rehypeCodeOptions,
-  remarkImageOptions,
-  remarkHeadingOptions,
-  remarkStructureOptions,
-  remarkCodeTabOptions,
-  ...mdxOptions
-}) {
-  const mdxExports = [
-    "structuredData",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
-  const remarkPlugins = pluginOption(
-    (v) => [
-      plugins.remarkGfm,
-      [
-        plugins.remarkHeading,
-        {
-          generateToc: false,
-          ...remarkHeadingOptions
-        }
-      ],
-      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
-      // Fumadocs 14 compatibility
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && plugins.remarkCodeTab,
-      ...v,
-      remarkStructureOptions !== false && [
-        plugins.remarkStructure,
-        remarkStructureOptions
-      ],
-      [remarkMdxExport, { values: mdxExports }]
-    ],
-    mdxOptions.remarkPlugins
-  );
-  const rehypePlugins = pluginOption(
-    (v) => [
-      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
-      ...v,
-      [plugins.rehypeToc]
-    ],
-    mdxOptions.rehypePlugins
-  );
-  return {
-    ...mdxOptions,
-    remarkPlugins,
-    rehypePlugins
-  };
-}
-var plugins;
-var init_mdx_options = __esm({
-  "src/utils/mdx-options.ts"() {
-    "use strict";
-    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-    init_remark_exports();
-  }
-});
-
 // src/map/watcher.ts
 var watcher_exports = {};
 __export(watcher_exports, {
@@ -199,8 +75,7 @@ module.exports = __toCommonJS(next_exports);
 var import_node_path2 = __toESM(require("path"), 1);
 
 // src/utils/config.ts
-var import_node_crypto = require("crypto");
-var fs = __toESM(require("fs"), 1);
+var fs = __toESM(require("fs/promises"), 1);
 var path = __toESM(require("path"), 1);
 var import_node_url = require("url");
 
@@ -231,23 +106,11 @@ function buildConfig(config) {
       null
     ];
   }
-  let cachedMdxOptions;
   return [
     null,
     {
       global: globalConfig,
       collections,
-      async getDefaultMDXOptions() {
-        if (cachedMdxOptions) return cachedMdxOptions;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
-        const mdxOptions = globalConfig?.mdxOptions ?? {};
-        if (typeof mdxOptions === "function") {
-          cachedMdxOptions = getDefaultMDXOptions2(await mdxOptions());
-        } else {
-          cachedMdxOptions = getDefaultMDXOptions2(mdxOptions);
-        }
-        return cachedMdxOptions;
-      },
       _runtime: {
         files: /* @__PURE__ */ new Map()
       }
@@ -259,13 +122,13 @@ function buildConfig(config) {
 function findConfigFile() {
   return path.resolve("source.config.ts");
 }
-var cache = /* @__PURE__ */ new Map();
-async function compileConfig(configPath) {
+var cache = null;
+async function compileConfig(configPath, outDir2) {
   const { build } = await import("esbuild");
   const transformed = await build({
     entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
-    outdir: ".source",
+    outdir: outDir2,
     target: "node18",
     write: true,
     platform: "node",
@@ -281,13 +144,12 @@ 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);
+  if (build) await compileConfig(configPath, ".source");
   const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
-  const config = import(`${url.href}?hash=${configPath}`).then((loaded) => {
+  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
     const [err, config2] = buildConfig(
       // every call to `loadConfig` will cause the previous cache to be ignored
       loaded
@@ -295,24 +157,24 @@ 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) {
-  const hash = (0, import_node_crypto.createHash)("md5");
-  const rs = fs.createReadStream(configPath);
-  for await (const chunk of rs) {
-    hash.update(chunk);
+  const stats = await fs.stat(configPath).catch(() => void 0);
+  if (stats) {
+    return stats.mtime.getTime().toString();
   }
-  return hash.digest("hex");
+  throw new Error("Cannot find config file");
 }
 
 // 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 +187,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 +303,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 +349,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 +360,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 +430,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 +455,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 +537,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");