fumadocs-mdx 11.3.1 → 11.4.0

package/dist/loader-mdx.js

@@ -1,10 +1,11 @@
-import {
-  remarkInclude
-} from "./chunk-PY2KKTR2.js";
 import {
   getConfigHash,
   loadConfigCached
-} from "./chunk-2ZPSMAUV.js";
+} from "./chunk-IU4D6M3A.js";
+import {
+  remarkInclude
+} from "./chunk-PY2KKTR2.js";
+import "./chunk-2DJQ3DOD.js";
 
 // src/loader-mdx.ts
 import * as path2 from "node:path";
@@ -52,11 +53,11 @@ function buildMDX(group, configHash, source, options = {}) {
 
 // src/utils/format-error.ts
 function formatError(message, error) {
-  const lines = [];
+  const lines2 = [];
   function walk(key, { _errors, ...rest }, padStart = 0) {
     if (key !== void 0 || _errors.length > 0) {
       const text = key ? `${key}: ${_errors.join("\n    ")}` : _errors.join("\n");
-      lines.push(
+      lines2.push(
         text.split("\n").map((line) => `${" ".repeat(padStart)}${line}`).join("\n")
       );
     }
@@ -65,7 +66,7 @@ function formatError(message, error) {
     }
   }
   walk(void 0, error.format());
-  return [message, ...lines].join("\n");
+  return [message, ...lines2].join("\n");
 }
 
 // src/utils/git-timestamp.ts
@@ -122,7 +123,6 @@ async function loader(source, callback) {
     collection = void 0;
   }
   const mdxOptions = collection?.mdxOptions ?? await config.getDefaultMDXOptions();
-  let frontmatter = matter.data;
   if (collection?.schema) {
     let schema = collection.schema;
     if (typeof schema === "function") {
@@ -140,7 +140,7 @@ async function loader(source, callback) {
         path: filePath
       });
     }
-    const result = await schema.safeParseAsync(frontmatter);
+    const result = await schema.safeParseAsync(matter.data);
     if (result.error) {
       callback(
         new Error(
@@ -149,21 +149,24 @@ async function loader(source, callback) {
       );
       return;
     }
-    frontmatter = result.data;
+    matter.data = result.data;
   }
   let timestamp;
   if (config.global?.lastModifiedTime === "git")
     timestamp = (await getGitTimestamp(filePath))?.getTime();
   try {
+    const lineOffset = "\n".repeat(
+      this.mode === "development" ? lines(source) - lines(matter.content) : 0
+    );
     const file = await buildMDX(
       collectionId ?? "global",
       configHash,
-      matter.content,
+      lineOffset + matter.content,
       {
         development: this.mode === "development",
         ...mdxOptions,
         filePath,
-        frontmatter,
+        frontmatter: matter.data,
         data: {
           lastModified: timestamp
         },
@@ -178,6 +181,13 @@ async function loader(source, callback) {
     callback(error);
   }
 }
+function lines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
 export {
   loader as default
 };

package/dist/{mdx-options-L5C3NQRY.js → mdx-options-CAU273O3.js}

@@ -1,6 +1,6 @@
 import {
   getDefaultMDXOptions
-} from "./chunk-6LEQ23AC.js";
+} from "./chunk-IOENRFUX.js";
 export {
   getDefaultMDXOptions
 };

package/dist/next/index.cjs

@@ -100,6 +100,7 @@ function getDefaultMDXOptions({
   remarkImageOptions,
   remarkHeadingOptions,
   remarkStructureOptions,
+  remarkCodeTabOptions,
   ...mdxOptions
 }) {
   const mdxExports = [
@@ -110,18 +111,20 @@ function getDefaultMDXOptions({
   ];
   const remarkPlugins = pluginOption(
     (v) => [
-      import_mdx_plugins.remarkGfm,
+      plugins.remarkGfm,
       [
-        import_mdx_plugins.remarkHeading,
+        plugins.remarkHeading,
         {
           generateToc: false,
           ...remarkHeadingOptions
         }
       ],
-      remarkImageOptions !== false && [import_mdx_plugins.remarkImage, remarkImageOptions],
+      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
+      // Fumadocs 14 compatibility
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && plugins.remarkCodeTab,
       ...v,
       remarkStructureOptions !== false && [
-        import_mdx_plugins.remarkStructure,
+        plugins.remarkStructure,
         remarkStructureOptions
       ],
       [remarkMdxExport, { values: mdxExports }]
@@ -130,9 +133,9 @@ function getDefaultMDXOptions({
   );
   const rehypePlugins = pluginOption(
     (v) => [
-      rehypeCodeOptions !== false && [import_mdx_plugins.rehypeCode, rehypeCodeOptions],
+      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
       ...v,
-      [import_mdx_plugins.rehypeToc]
+      [plugins.rehypeToc]
     ],
     mdxOptions.rehypePlugins
   );
@@ -142,11 +145,11 @@ function getDefaultMDXOptions({
     rehypePlugins
   };
 }
-var import_mdx_plugins;
+var plugins;
 var init_mdx_options = __esm({
   "src/utils/mdx-options.ts"() {
     "use strict";
-    import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
     init_remark_exports();
   }
 });
@@ -187,40 +190,11 @@ module.exports = __toCommonJS(next_exports);
 // src/next/create.ts
 var import_node_path2 = __toESM(require("path"), 1);
 
-// src/config/load.ts
+// src/utils/load-config.ts
 var path = __toESM(require("path"), 1);
 var import_node_url = require("url");
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
-async function loadConfig(configPath) {
-  const { build } = await import("esbuild");
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
-  const transformed = await build({
-    entryPoints: [{ in: configPath, out: "source.config" }],
-    bundle: true,
-    outdir: ".source",
-    target: "node18",
-    write: true,
-    platform: "node",
-    format: "esm",
-    packages: "external",
-    outExtension: {
-      ".js": ".mjs"
-    },
-    allowOverwrite: true
-  });
-  if (transformed.errors.length > 0) {
-    throw new Error("failed to compile configuration file");
-  }
-  const loaded = await import(`${url.href}?hash=${Date.now().toString()}`);
-  const [err, config] = buildConfig(
-    // every call to `loadConfig` will cause the previous cache to be ignored
-    loaded
-  );
-  if (err !== null) throw new Error(err);
-  return config;
-}
+
+// src/config/build.ts
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
   let globalConfig;
@@ -268,13 +242,46 @@ function buildConfig(config) {
   ];
 }
 
+// src/utils/load-config.ts
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+async function loadConfig(configPath) {
+  const { build } = await import("esbuild");
+  const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: ".source",
+    target: "node18",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+  const loaded = await import(`${url.href}?hash=${Date.now().toString()}`);
+  const [err, config] = buildConfig(
+    // every call to `loadConfig` will cause the previous cache to be ignored
+    loaded
+  );
+  if (err !== null) throw new Error(err);
+  return config;
+}
+
 // src/map/index.ts
 var path3 = __toESM(require("path"), 1);
 var fs2 = __toESM(require("fs"), 1);
 var import_promises = require("fs/promises");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 
-// src/config/cached.ts
+// src/utils/config-cache.ts
 var import_node_crypto = require("crypto");
 var fs = __toESM(require("fs"), 1);
 var cache = /* @__PURE__ */ new Map();
@@ -316,48 +323,62 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
   const imports = [
     {
       type: "named",
-      names: ["toRuntime", "toRuntimeAsync"],
+      names: ["toRuntime"],
       specifier: "fumadocs-mdx"
     }
   ];
-  const importedCollections = /* @__PURE__ */ new Set();
-  async function generateEntry(file, collectionName, collection, importId) {
-    if (collection.type === "doc" && collection.async) {
-      const importPath = `${toImportPath(file.absolutePath, outDir2)}?hash=${configHash}&collection=${collectionName}`;
-      const frontmatter = await getFrontmatter(file.absolutePath);
-      return `toRuntimeAsync(${JSON.stringify(frontmatter)}, () => import(${JSON.stringify(importPath)}), ${JSON.stringify(file)})`;
-    }
-    imports.push({
-      type: "namespace",
-      name: importId,
-      specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${collectionName}&hash=${configHash}`
-    });
-    return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
-  }
+  let asyncInit = false;
+  const lines = [];
   config._runtime.files.clear();
   const entries = Array.from(config.collections.entries());
   const declares = entries.map(async ([k, collection]) => {
     const files = await getCollectionFiles(collection);
+    if (collection.type === "doc" && collection.async) {
+      if (!asyncInit) {
+        imports.push(
+          {
+            type: "namespace",
+            specifier: toImportPath(configPath, outDir2),
+            name: "_source"
+          },
+          {
+            type: "named",
+            specifier: "fumadocs-mdx/runtime/async",
+            names: ["asyncFiles", "buildConfig"]
+          }
+        );
+        lines.unshift(
+          "const [err, _sourceConfig] = buildConfig(_source)",
+          "if (err) throw new Error(err)"
+        );
+        asyncInit = true;
+      }
+      const entries2 = files.map(async (file) => {
+        const frontmatter = await getFrontmatter(file.absolutePath);
+        return JSON.stringify({
+          frontmatter,
+          file
+        });
+      });
+      return `export const ${k} = asyncFiles([${(await Promise.all(entries2)).join(", ")}], "${k}", _sourceConfig)`;
+    }
     const items = files.map(async (file, i) => {
       config._runtime.files.set(file.absolutePath, k);
-      return generateEntry(file, k, collection, `${k}_${i}`);
+      const importId = `${k}_${i}`;
+      imports.push({
+        type: "namespace",
+        name: importId,
+        specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${k}&hash=${configHash}`
+      });
+      return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
     });
     const resolvedItems = await Promise.all(items);
-    if (collection.transform) {
-      if (config.global) importedCollections.add("default");
-      importedCollections.add(k);
-    }
-    return collection.transform ? `export const ${k} = await Promise.all([${resolvedItems.join(", ")}].map(v => c_${k}.transform(v, ${config.global ? "c_default" : "undefined"})));` : `export const ${k} = [${resolvedItems.join(", ")}];`;
+    return `export const ${k} = [${resolvedItems.join(", ")}];`;
   });
   const resolvedDeclares = await Promise.all(declares);
-  if (importedCollections.size > 0) {
-    imports.push({
-      type: "named",
-      names: Array.from(importedCollections.values()).sort().map((v) => [v, `c_${v}`]),
-      specifier: toImportPath(configPath, outDir2)
-    });
-  }
-  return [...imports.map(getImportCode), ...resolvedDeclares].join("\n");
+  return [...imports.map(getImportCode), ...lines, ...resolvedDeclares].join(
+    "\n"
+  );
 }
 async function getCollectionFiles(collection) {
   const files = /* @__PURE__ */ new Map();
@@ -422,14 +443,41 @@ async function start(dev, configPath, outDir2) {
   const typeOut = path3.resolve(outDir2, `index.d.ts`);
   const frontmatterCache = /* @__PURE__ */ new Map();
   let hookUpdate = false;
-  const readFrontmatter = async (file) => {
+  async function readFrontmatter(file) {
+    hookUpdate = true;
     const cached = frontmatterCache.get(file);
     if (cached) return cached;
-    hookUpdate = true;
-    return (0, import_gray_matter.default)({
-      content: await (0, import_promises.readFile)(file).then((res) => res.toString())
-    }).data;
-  };
+    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));
+    }).then((res) => {
+      frontmatterCache.set(file, res);
+      return res;
+    });
+  }
   fs2.mkdirSync(outDir2, { recursive: true });
   fs2.writeFileSync(
     jsOut,

package/dist/next/index.js

@@ -3,7 +3,8 @@ import {
   getConfigHash,
   loadConfig,
   loadConfigCached
-} from "../chunk-2ZPSMAUV.js";
+} from "../chunk-IU4D6M3A.js";
+import "../chunk-2DJQ3DOD.js";
 
 // src/next/create.ts
 import path3 from "node:path";
@@ -11,7 +12,7 @@ import path3 from "node:path";
 // src/map/index.ts
 import * as path2 from "node:path";
 import * as fs from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
 import grayMatter from "gray-matter";
 
 // src/map/generate.ts
@@ -34,48 +35,62 @@ async function generateJS(configPath, config, outputPath, configHash, getFrontma
   const imports = [
     {
       type: "named",
-      names: ["toRuntime", "toRuntimeAsync"],
+      names: ["toRuntime"],
       specifier: "fumadocs-mdx"
     }
   ];
-  const importedCollections = /* @__PURE__ */ new Set();
-  async function generateEntry(file, collectionName, collection, importId) {
-    if (collection.type === "doc" && collection.async) {
-      const importPath = `${toImportPath(file.absolutePath, outDir2)}?hash=${configHash}&collection=${collectionName}`;
-      const frontmatter = await getFrontmatter(file.absolutePath);
-      return `toRuntimeAsync(${JSON.stringify(frontmatter)}, () => import(${JSON.stringify(importPath)}), ${JSON.stringify(file)})`;
-    }
-    imports.push({
-      type: "namespace",
-      name: importId,
-      specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${collectionName}&hash=${configHash}`
-    });
-    return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
-  }
+  let asyncInit = false;
+  const lines = [];
   config._runtime.files.clear();
   const entries = Array.from(config.collections.entries());
   const declares = entries.map(async ([k, collection]) => {
     const files = await getCollectionFiles(collection);
+    if (collection.type === "doc" && collection.async) {
+      if (!asyncInit) {
+        imports.push(
+          {
+            type: "namespace",
+            specifier: toImportPath(configPath, outDir2),
+            name: "_source"
+          },
+          {
+            type: "named",
+            specifier: "fumadocs-mdx/runtime/async",
+            names: ["asyncFiles", "buildConfig"]
+          }
+        );
+        lines.unshift(
+          "const [err, _sourceConfig] = buildConfig(_source)",
+          "if (err) throw new Error(err)"
+        );
+        asyncInit = true;
+      }
+      const entries2 = files.map(async (file) => {
+        const frontmatter = await getFrontmatter(file.absolutePath);
+        return JSON.stringify({
+          frontmatter,
+          file
+        });
+      });
+      return `export const ${k} = asyncFiles([${(await Promise.all(entries2)).join(", ")}], "${k}", _sourceConfig)`;
+    }
     const items = files.map(async (file, i) => {
       config._runtime.files.set(file.absolutePath, k);
-      return generateEntry(file, k, collection, `${k}_${i}`);
+      const importId = `${k}_${i}`;
+      imports.push({
+        type: "namespace",
+        name: importId,
+        specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${k}&hash=${configHash}`
+      });
+      return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
     });
     const resolvedItems = await Promise.all(items);
-    if (collection.transform) {
-      if (config.global) importedCollections.add("default");
-      importedCollections.add(k);
-    }
-    return collection.transform ? `export const ${k} = await Promise.all([${resolvedItems.join(", ")}].map(v => c_${k}.transform(v, ${config.global ? "c_default" : "undefined"})));` : `export const ${k} = [${resolvedItems.join(", ")}];`;
+    return `export const ${k} = [${resolvedItems.join(", ")}];`;
   });
   const resolvedDeclares = await Promise.all(declares);
-  if (importedCollections.size > 0) {
-    imports.push({
-      type: "named",
-      names: Array.from(importedCollections.values()).sort().map((v) => [v, `c_${v}`]),
-      specifier: toImportPath(configPath, outDir2)
-    });
-  }
-  return [...imports.map(getImportCode), ...resolvedDeclares].join("\n");
+  return [...imports.map(getImportCode), ...lines, ...resolvedDeclares].join(
+    "\n"
+  );
 }
 async function getCollectionFiles(collection) {
   const files = /* @__PURE__ */ new Map();
@@ -140,14 +155,41 @@ async function start(dev, configPath, outDir2) {
   const typeOut = path2.resolve(outDir2, `index.d.ts`);
   const frontmatterCache = /* @__PURE__ */ new Map();
   let hookUpdate = false;
-  const readFrontmatter = async (file) => {
+  async function readFrontmatter(file) {
+    hookUpdate = true;
     const cached = frontmatterCache.get(file);
     if (cached) return cached;
-    hookUpdate = true;
-    return grayMatter({
-      content: await readFile(file).then((res) => res.toString())
-    }).data;
-  };
+    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));
+    }).then((res) => {
+      frontmatterCache.set(file, res);
+      return res;
+    });
+  }
   fs.mkdirSync(outDir2, { recursive: true });
   fs.writeFileSync(
     jsOut,