fumadocs-mdx 11.9.1 → 11.10.0

package/dist/loader-mdx.cjs

@@ -37,9 +37,9 @@ function remarkPostprocess({
   return (tree, file) => {
     let title;
     const urls = [];
-    (0, import_unist_util_visit.visit)(tree, ["heading", "link"], (node) => {
+    (0, import_unist_util_visit2.visit)(tree, ["heading", "link"], (node) => {
       if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode(node);
+        title = flattenNode2(node);
       }
       if (node.type !== "link") return;
       urls.push({
@@ -58,9 +58,9 @@ function remarkPostprocess({
     }
   };
 }
-function flattenNode(node) {
+function flattenNode2(node) {
   if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
+    return node.children.map((child) => flattenNode2(child)).join("");
   if ("value" in node) return node.value;
   return "";
 }
@@ -98,11 +98,11 @@ function getMdastExport(name, value) {
     }
   };
 }
-var import_unist_util_visit, import_estree_util_value_to_estree;
+var import_unist_util_visit2, import_estree_util_value_to_estree;
 var init_remark_postprocess = __esm({
   "src/mdx-plugins/remark-postprocess.ts"() {
     "use strict";
-    import_unist_util_visit = require("unist-util-visit");
+    import_unist_util_visit2 = require("unist-util-visit");
     import_estree_util_value_to_estree = require("estree-util-value-to-estree");
   }
 });
@@ -203,137 +203,91 @@ __export(loader_mdx_exports, {
   default: () => loader
 });
 module.exports = __toCommonJS(loader_mdx_exports);
-var path4 = __toESM(require("path"), 1);
-var import_node_querystring = require("querystring");
 
-// src/utils/config.ts
-var fs = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var import_node_url = require("url");
+// src/utils/fuma-matter.ts
+var import_js_yaml = require("js-yaml");
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = (0, import_js_yaml.load)(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
 
-// src/config/build.ts
-function buildConfig(config) {
-  const collections = /* @__PURE__ */ new Map();
-  let globalConfig = {};
-  for (const [k, v] of Object.entries(config)) {
-    if (!v) {
-      continue;
-    }
-    if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs") {
-        collections.set(k, v);
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(k, v);
-        continue;
-      }
-    }
-    if (k === "default" && v) {
-      globalConfig = v;
-      continue;
-    }
-    throw new Error(
-      `Unknown export "${k}", you can only export collections from source configuration file.`
+// src/utils/validation.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
     );
+    this.title = message;
+    this.issues = issues;
   }
-  const mdxOptionsCache = /* @__PURE__ */ new Map();
-  return {
-    global: globalConfig,
-    collections,
-    async getDefaultMDXOptions(mode = "default") {
-      const cached = mdxOptionsCache.get(mode);
-      if (cached) return cached;
-      const input = this.global.mdxOptions;
-      async function uncached() {
-        const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
-        if (options?.preset === "minimal") return options;
-        return getDefaultMDXOptions2({
-          ...options,
-          _withoutBundler: mode === "remote"
-        });
-      }
-      const result = uncached();
-      mdxOptionsCache.set(mode, result);
-      return result;
+  toStringFormatted() {
+    return [
+      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => import_picocolors.default.redBright(
+          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        )
+      )
+    ].join("\n");
+  }
+};
+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 ValidationError(errorMessage, result.issues);
     }
-  };
+    return result.value;
+  }
+  return data;
 }
 
-// src/utils/config.ts
-var cache = null;
-async function isZod3() {
+// src/utils/git-timestamp.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_tinyexec = require("tinyexec");
+var cache = /* @__PURE__ */ new Map();
+async function getGitTimestamp(file) {
+  const cached = cache.get(file);
+  if (cached) return cached;
   try {
-    const content = JSON.parse(
-      (await fs.readFile("node_modules/zod/package.json")).toString()
+    const out = await (0, import_tinyexec.x)(
+      "git",
+      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
     );
-    const version = content.version;
-    return typeof version === "string" && version.startsWith("3.");
+    const time = new Date(out.stdout);
+    cache.set(file, time);
+    return time;
   } catch {
-    return false;
-  }
-}
-function createCompatZodPlugin() {
-  return {
-    name: "replace-zod-import",
-    async setup(build) {
-      const usingZod3 = await isZod3();
-      if (!usingZod3) return;
-      console.warn(
-        "[Fumadocs MDX] Noticed Zod v3 in your node_modules, we recommend upgrading to Zod v4 for better compatibility."
-      );
-      build.onResolve({ filter: /^fumadocs-mdx\/config$/ }, () => {
-        return {
-          path: "fumadocs-mdx/config/zod-3",
-          external: true
-        };
-      });
-    }
-  };
-}
-async function compileConfig(configPath, outDir) {
-  const { build } = await import("esbuild");
-  const transformed = await build({
-    entryPoints: [{ in: configPath, out: "source.config" }],
-    bundle: true,
-    outdir: outDir,
-    target: "node20",
-    write: true,
-    platform: "node",
-    format: "esm",
-    packages: "external",
-    plugins: [createCompatZodPlugin()],
-    outExtension: {
-      ".js": ".mjs"
-    },
-    allowOverwrite: true
-  });
-  if (transformed.errors.length > 0) {
-    throw new Error("failed to compile configuration file");
-  }
-}
-async function loadConfig(configPath, outDir, hash, build = false) {
-  if (cache && cache.hash === hash) {
-    return await cache.config;
+    return;
   }
-  if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(outDir, "source.config.mjs"));
-  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
-    return buildConfig(
-      // every call to `loadConfig` will cause the previous cache to be ignored
-      loaded
-    );
-  });
-  if (hash) cache = { config, hash };
-  return await config;
 }
-async function getConfigHash(configPath) {
-  const stats = await fs.stat(configPath).catch(() => void 0);
-  if (stats) {
-    return stats.mtime.getTime().toString();
+
+// src/utils/count-lines.ts
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
   }
-  throw new Error("Cannot find config file");
+  return num;
 }
 
 // src/utils/build-mdx.ts
@@ -341,34 +295,16 @@ var import_mdx = require("@mdx-js/mdx");
 
 // src/mdx-plugins/remark-include.ts
 var import_unified = require("unified");
-var import_unist_util_visit2 = require("unist-util-visit");
+var import_unist_util_visit = require("unist-util-visit");
 var path2 = __toESM(require("path"), 1);
-var fs2 = __toESM(require("fs/promises"), 1);
-
-// src/utils/fuma-matter.ts
-var import_js_yaml = require("js-yaml");
-var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
-function fumaMatter(input) {
-  const output = { matter: "", data: {}, content: input };
-  const match = regex.exec(input);
-  if (!match) {
-    return output;
-  }
-  output.matter = match[0];
-  output.content = input.slice(match[0].length);
-  const loaded = (0, import_js_yaml.load)(match[1]);
-  output.data = loaded ?? {};
-  return output;
-}
-
-// src/mdx-plugins/remark-include.ts
+var fs = __toESM(require("fs/promises"), 1);
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
 var baseProcessor = (0, import_unified.unified)().use(import_mdx_plugins.remarkHeading);
-function flattenNode2(node) {
+function flattenNode(node) {
   if ("children" in node)
-    return node.children.map((child) => flattenNode2(child)).join("");
+    return node.children.map((child) => flattenNode(child)).join("");
   if ("value" in node) return node.value;
   return "";
 }
@@ -408,7 +344,7 @@ function remarkInclude() {
   async function embedContent(file, heading, params, data) {
     let content;
     try {
-      content = (await fs2.readFile(file)).toString();
+      content = (await fs.readFile(file)).toString();
     } catch (e) {
       throw new Error(
         `failed to read file ${file}
@@ -447,14 +383,14 @@ ${e instanceof Error ? e.message : String(e)}`,
   }
   async function update(tree, directory, data) {
     const queue = [];
-    (0, import_unist_util_visit2.visit)(
+    (0, import_unist_util_visit.visit)(
       tree,
       ["mdxJsxFlowElement", "mdxJsxTextElement"],
       (_node, _, parent) => {
         const node = _node;
         if (node.name !== TagName) return;
         const params = {};
-        const specifier = flattenNode2(node);
+        const specifier = flattenNode(node);
         if (specifier.length === 0) return "skip";
         for (const attr of node.attributes) {
           if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
@@ -521,140 +457,284 @@ async function buildMDX(cacheKey, source, options) {
   });
 }
 
-// src/utils/git-timestamp.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_tinyexec = require("tinyexec");
-var cache3 = /* @__PURE__ */ new Map();
-async function getGitTimestamp(file) {
-  const cached = cache3.get(file);
-  if (cached) return cached;
-  try {
-    const out = await (0, import_tinyexec.x)(
-      "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
+// src/loaders/mdx.ts
+var import_zod = require("zod");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var querySchema = import_zod.z.object({
+  only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
+  collection: import_zod.z.string().optional(),
+  hash: import_zod.z.string().describe(
+    "the hash of config, used for revalidation on Turbopack/Webpack."
+  ).optional()
+}).loose();
+var cacheEntry = import_zod.z.object({
+  code: import_zod.z.string(),
+  map: import_zod.z.any().optional(),
+  hash: import_zod.z.string().optional()
+});
+function createMdxLoader(configLoader) {
+  return async ({
+    source: value,
+    development: isDevelopment,
+    query,
+    compiler,
+    filePath
+  }) => {
+    const matter = fumaMatter(value);
+    const parsed = querySchema.parse(query);
+    const loaded = await configLoader.getConfig(parsed.hash);
+    const cacheDir = isDevelopment ? void 0 : loaded.global.experimentalBuildCache;
+    const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+    if (cacheDir) {
+      const cached = await import_promises.default.readFile(import_node_path2.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      if (cached && cached.hash === generateCacheHash(value)) return cached;
+    }
+    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    let schema;
+    let mdxOptions;
+    switch (collection?.type) {
+      case "doc":
+        mdxOptions = collection.mdxOptions;
+        schema = collection.schema;
+        break;
+      case "docs":
+        mdxOptions = collection.docs.mdxOptions;
+        schema = collection.docs.schema;
+        break;
+    }
+    if (schema) {
+      matter.data = await validate(
+        schema,
+        matter.data,
+        {
+          source: value,
+          path: filePath
+        },
+        `invalid frontmatter in ${filePath}`
+      );
+    }
+    if (parsed.only === "frontmatter") {
+      return {
+        code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+        map: null
+      };
+    }
+    const data = {};
+    if (loaded.global.lastModifiedTime === "git") {
+      data.lastModified = (await getGitTimestamp(filePath))?.getTime();
+    }
+    const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+    const compiled = await buildMDX(
+      `${parsed.hash ?? ""}:${parsed.collection ?? "global"}`,
+      "\n".repeat(lineOffset) + matter.content,
       {
-        throwOnError: true
+        development: isDevelopment,
+        ...mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        data,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler
       }
     );
-    const time = new Date(out.stdout);
-    cache3.set(file, time);
-    return time;
-  } catch {
-    return;
+    const out = {
+      code: String(compiled.value),
+      map: compiled.map
+    };
+    if (cacheDir) {
+      await import_promises.default.mkdir(cacheDir, { recursive: true });
+      await import_promises.default.writeFile(
+        import_node_path2.default.join(cacheDir, cacheKey),
+        JSON.stringify({
+          ...out,
+          hash: generateCacheHash(value)
+        })
+      );
+    }
+    return out;
+  };
+}
+function generateCacheHash(input) {
+  return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
+}
+
+// src/utils/config.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/config/build.ts
+function buildConfig(config) {
+  const collections = /* @__PURE__ */ new Map();
+  let globalConfig = {};
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "type" in v) {
+      if (v.type === "docs") {
+        collections.set(k, v);
+        continue;
+      }
+      if (v.type === "doc" || v.type === "meta") {
+        collections.set(k, v);
+        continue;
+      }
+    }
+    if (k === "default" && v) {
+      globalConfig = v;
+      continue;
+    }
+    throw new Error(
+      `Unknown export "${k}", you can only export collections from source configuration file.`
+    );
   }
+  const mdxOptionsCache = /* @__PURE__ */ new Map();
+  return {
+    global: globalConfig,
+    collections,
+    async getDefaultMDXOptions(mode = "default") {
+      const cached = mdxOptionsCache.get(mode);
+      if (cached) return cached;
+      const input = this.global.mdxOptions;
+      async function uncached() {
+        const options = typeof input === "function" ? await input() : input;
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
+        if (options?.preset === "minimal") return options;
+        return getDefaultMDXOptions2({
+          ...options,
+          _withoutBundler: mode === "remote"
+        });
+      }
+      const result = uncached();
+      mdxOptionsCache.set(mode, result);
+      return result;
+    }
+  };
 }
 
-// src/utils/validation.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
-var ValidationError = class extends Error {
-  constructor(message, issues) {
-    super(
-      `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+// src/utils/config.ts
+var cache3 = null;
+async function isZod3() {
+  try {
+    const content = JSON.parse(
+      (await fs3.readFile("node_modules/zod/package.json")).toString()
     );
-    this.title = message;
-    this.issues = issues;
+    const version = content.version;
+    return typeof version === "string" && version.startsWith("3.");
+  } catch {
+    return false;
   }
-  toStringFormatted() {
-    return [
-      import_picocolors.default.bold(`[MDX] ${this.title}:`),
-      ...this.issues.map(
-        (issue) => import_picocolors.default.redBright(
-          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-        )
-      )
-    ].join("\n");
+}
+function createCompatZodPlugin() {
+  return {
+    name: "replace-zod-import",
+    async setup(build) {
+      const usingZod3 = await isZod3();
+      if (!usingZod3) return;
+      console.warn(
+        "[Fumadocs MDX] Noticed Zod v3 in your node_modules, we recommend upgrading to Zod v4 for better compatibility."
+      );
+      build.onResolve({ filter: /^fumadocs-mdx\/config$/ }, () => {
+        return {
+          path: "fumadocs-mdx/config/zod-3",
+          external: true
+        };
+      });
+    }
+  };
+}
+async function compileConfig(configPath, outDir) {
+  const { build } = await import("esbuild");
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins: [createCompatZodPlugin()],
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
   }
-};
-async function validate(schema, data, context, errorMessage) {
-  if (typeof schema === "function" && !("~standard" in schema)) {
-    schema = schema(context);
+}
+async function loadConfig(configPath, outDir, hash, build = false) {
+  if (cache3 && cache3.hash === hash) {
+    return await cache3.config;
   }
-  if ("~standard" in schema) {
-    const result = await schema["~standard"].validate(
-      data
+  if (build) await compileConfig(configPath, outDir);
+  const url = (0, import_node_url.pathToFileURL)(path4.resolve(outDir, "source.config.mjs"));
+  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
+    return buildConfig(
+      // every call to `loadConfig` will cause the previous cache to be ignored
+      loaded
     );
-    if (result.issues) {
-      throw new ValidationError(errorMessage, result.issues);
-    }
-    return result.value;
+  });
+  if (hash) cache3 = { config, hash };
+  return await config;
+}
+async function getConfigHash(configPath) {
+  const stats = await fs3.stat(configPath).catch(() => void 0);
+  if (stats) {
+    return stats.mtime.getTime().toString();
   }
-  return data;
+  throw new Error("Cannot find config file");
 }
 
-// src/utils/count-lines.ts
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
+// src/loaders/config-loader.ts
+function dynamicConfig(configPath, outDir) {
+  return {
+    async getConfig(hash) {
+      return loadConfig(
+        configPath,
+        outDir,
+        hash ?? await getConfigHash(configPath)
+      );
+    }
+  };
+}
+
+// src/loaders/adapter.ts
+var import_node_url2 = require("url");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_querystring = require("querystring");
+var import_node_path3 = __toESM(require("path"), 1);
+function toWebpack(loader2) {
+  return async function(source, callback) {
+    try {
+      const result = await loader2({
+        filePath: this.resourcePath,
+        query: (0, import_node_querystring.parse)(this.resourceQuery),
+        source,
+        development: this.mode === "development",
+        compiler: this
+      });
+      callback(void 0, result.code, result.map);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return callback(new Error(error.toStringFormatted()));
+      }
+      if (!(error instanceof Error)) throw error;
+      const fpath = import_node_path3.default.relative(this.context, this.resourcePath);
+      error.message = `${fpath}:${error.name}: ${error.message}`;
+      callback(error);
+    }
+  };
 }
 
 // src/loader-mdx.ts
+var instance;
 async function loader(source, callback) {
   this.cacheable(true);
-  const context = this.context;
-  const filePath = this.resourcePath;
   const { configPath, outDir } = this.getOptions();
-  const matter = fumaMatter(source);
-  const {
-    hash: configHash = await getConfigHash(configPath),
-    collection: collectionId
-  } = (0, import_node_querystring.parse)(this.resourceQuery.slice(1));
-  const config = await loadConfig(configPath, outDir, configHash);
-  let collection = collectionId !== void 0 ? config.collections.get(collectionId) : void 0;
-  if (collection && collection.type === "docs") collection = collection.docs;
-  if (collection && collection.type !== "doc") {
-    collection = void 0;
-  }
-  let frontmatter = matter.data;
-  const mdxOptions = collection?.mdxOptions ?? await config.getDefaultMDXOptions();
-  if (collection?.schema) {
-    try {
-      frontmatter = await validate(
-        collection.schema,
-        frontmatter,
-        {
-          source,
-          path: filePath
-        },
-        `invalid frontmatter in ${filePath}`
-      );
-    } catch (e) {
-      if (e instanceof ValidationError) {
-        return callback(new Error(e.toStringFormatted()));
-      }
-      return callback(e);
-    }
-  }
-  let timestamp;
-  if (config.global?.lastModifiedTime === "git") {
-    timestamp = (await getGitTimestamp(filePath))?.getTime();
-  }
-  try {
-    const lineOffset = "\n".repeat(
-      this.mode === "development" ? countLines(matter.matter) : 0
-    );
-    const file = await buildMDX(
-      `${configHash}:${collectionId ?? "global"}`,
-      lineOffset + matter.content,
-      {
-        development: this.mode === "development",
-        ...mdxOptions,
-        filePath,
-        frontmatter,
-        data: {
-          lastModified: timestamp
-        },
-        _compiler: this
-      }
-    );
-    callback(void 0, String(file.value), file.map ?? void 0);
-  } catch (error) {
-    if (!(error instanceof Error)) throw error;
-    const fpath = path4.relative(context, filePath);
-    error.message = `${fpath}:${error.name}: ${error.message}`;
-    callback(error);
-  }
+  instance ??= toWebpack(createMdxLoader(dynamicConfig(configPath, outDir)));
+  await instance.call(this, source, callback);
 }