fumadocs-mdx 11.6.11 → 11.7.1

package/dist/vite/index.js

@@ -1,13 +1,19 @@
 import {
   buildMDX,
   countLines
-} from "../chunk-6PDS7MUA.js";
+} from "../chunk-C5INPAZJ.js";
+import {
+  getGlobPatterns,
+  ident,
+  toImportPath
+} from "../chunk-OWZSTKKX.js";
 import {
   buildConfig
-} from "../chunk-DRVUBK5B.js";
+} from "../chunk-GWR7KMRU.js";
 import {
-  loadDefaultOptions
-} from "../chunk-64MMPGML.js";
+  ValidationError,
+  validate
+} from "../chunk-ZOWJF3OH.js";
 import "../chunk-AVMO2SRO.js";
 import {
   fumaMatter
@@ -15,43 +21,147 @@ import {
 
 // src/vite/index.ts
 import { parse } from "querystring";
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { load } from "js-yaml";
 var fileRegex = /\.(md|mdx)$/;
-function unstable_mdx(config, _options = {}) {
+var onlySchema = z.literal(["frontmatter", "all"]);
+function mdx(config, options = {}) {
+  const { generateIndexFile = true, configPath = "source.config.ts" } = options;
   const [err, loaded] = buildConfig(config);
   if (err || !loaded) {
     throw new Error(err);
   }
   return {
     name: "fumadocs-mdx",
-    // TODO: need a way to generate .source folder that works for non-RSC based frameworks, currently, we need to dynamic import MDX files using `import.meta.glob`.
-    // at the moment, RR and Tanstack Start has no stable support for RSC yet.
+    // needed, otherwise other plugins will be executed before our `transform`.
+    enforce: "pre",
+    async buildStart() {
+      if (!generateIndexFile) return;
+      console.log("[Fumadocs MDX] Generating index files");
+      const outdir = process.cwd();
+      const outFile = "source.generated.ts";
+      const lines = [
+        `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
+        `import type * as Config from '${toImportPath(configPath, {
+          relativeTo: outdir
+        })}';`,
+        "",
+        `export const create = fromConfig<typeof Config>();`
+      ];
+      function docs(name, collection) {
+        const args = [
+          ident(`doc: ${generateGlob(name, collection.docs)}`),
+          ident(`meta: ${generateGlob(name, collection.meta)}`)
+        ].join(",\n");
+        return `export const ${name} = create.docs("${name}", {
+${args}
+});`;
+      }
+      function doc(name, collection) {
+        return `export const ${name} = create.doc("${name}", ${generateGlob(name, collection)});`;
+      }
+      function meta(name, collection) {
+        return `export const ${name} = create.meta("${name}", ${generateGlob(name, collection)});`;
+      }
+      for (const [name, collection] of loaded.collections.entries()) {
+        lines.push("");
+        if (collection.type === "docs") {
+          lines.push(docs(name, collection));
+        } else if (collection.type === "meta") {
+          lines.push(meta(name, collection));
+        } else {
+          lines.push(doc(name, collection));
+        }
+      }
+      await fs.writeFile(path.join(outdir, outFile), lines.join("\n"));
+    },
     async transform(value, id) {
-      const [path, query = ""] = id.split("?");
-      if (!fileRegex.test(path)) return;
+      const [path2, query = ""] = id.split("?");
+      const isJson = path2.endsWith(".json");
+      const isYaml = path2.endsWith(".yaml");
+      if (isJson || isYaml) {
+        const parsed2 = parse(query);
+        const collection2 = parsed2.collection ? loaded.collections.get(parsed2.collection) : void 0;
+        if (!collection2) return null;
+        let schema2;
+        switch (collection2.type) {
+          case "meta":
+            schema2 = collection2.schema;
+            break;
+          case "docs":
+            schema2 = collection2.meta.schema;
+            break;
+        }
+        if (!schema2) return null;
+        let data;
+        try {
+          data = isJson ? JSON.parse(value) : load(value);
+        } catch {
+          return null;
+        }
+        const out = await validate(
+          schema2,
+          data,
+          { path: path2, source: value },
+          `invalid data in ${path2}`
+        );
+        return {
+          code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
+          map: null
+        };
+      }
+      if (!fileRegex.test(path2)) return;
       const matter = fumaMatter(value);
       const isDevelopment = this.environment.mode === "dev";
-      const { collection: collectionId, raw } = parse(query);
-      const collection = collectionId ? loaded.collections.get(collectionId) : void 0;
-      const lineOffset = "\n".repeat(
-        isDevelopment ? countLines(matter.matter) : 0
-      );
+      const parsed = parse(query);
+      const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+      const only = parsed.only ? onlySchema.parse(parsed.only) : "all";
+      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;
       }
-      mdxOptions ??= await loadDefaultOptions(loaded);
+      if (schema) {
+        try {
+          matter.data = await validate(
+            schema,
+            matter.data,
+            {
+              source: value,
+              path: path2
+            },
+            `invalid frontmatter in ${path2}`
+          );
+        } catch (e) {
+          if (e instanceof ValidationError) {
+            throw new Error(e.toStringFormatted());
+          }
+          throw e;
+        }
+      }
+      if (only === "frontmatter") {
+        return {
+          code: `export const frontmatter = ${JSON.stringify(matter.data)}`
+        };
+      }
+      mdxOptions ??= await loaded.getDefaultMDXOptions();
+      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
       const file = await buildMDX(
-        collectionId ?? "global",
-        lineOffset + matter.content,
+        parsed.collection ?? "global",
+        "\n".repeat(lineOffset) + matter.content,
         {
           development: isDevelopment,
           ...mdxOptions,
-          filePath: path,
+          filePath: path2,
           frontmatter: matter.data,
           _compiler: {
             addDependency: (file2) => {
@@ -61,11 +171,46 @@ function unstable_mdx(config, _options = {}) {
         }
       );
       return {
-        code: typeof raw === "string" ? `export default ${JSON.stringify(file.value)}` : String(file.value)
+        code: String(file.value),
+        map: file.map
       };
     }
   };
 }
+function generateGlob(name, collection) {
+  const patterns = mapGlobPatterns(getGlobPatterns(collection));
+  const options = {
+    query: {
+      collection: name
+    },
+    base: getGlobBase(collection)
+  };
+  if (collection.type === "meta") {
+    options.import = "default";
+  }
+  return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(options, null, 2)})`;
+}
+function mapGlobPatterns(patterns) {
+  return patterns.map((file) => {
+    if (file.startsWith("./")) return file;
+    if (file.startsWith("/")) return `.${file}`;
+    return `./${file}`;
+  });
+}
+function getGlobBase(collection) {
+  let dir = collection.dir;
+  if (Array.isArray(dir)) {
+    if (dir.length !== 1)
+      throw new Error(
+        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
+      );
+    dir = dir[0];
+  }
+  if (!dir.startsWith("./") && !dir.startsWith("/")) {
+    return "/" + dir;
+  }
+  return dir;
+}
 export {
-  unstable_mdx as default
+  mdx as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "11.6.11",
+  "version": "11.7.1",
   "description": "The built-in source for Fumadocs",
   "keywords": [
     "NextJs",
@@ -32,6 +32,10 @@
       "import": "./dist/runtime/async.js",
       "types": "./dist/runtime/async.d.ts"
     },
+    "./runtime/vite": {
+      "import": "./dist/runtime/vite.js",
+      "types": "./dist/runtime/vite.d.ts"
+    },
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
@@ -50,7 +54,7 @@
     "@mdx-js/mdx": "^3.1.0",
     "@standard-schema/spec": "^1.0.0",
     "chokidar": "^4.0.3",
-    "esbuild": "^0.25.6",
+    "esbuild": "^0.25.8",
     "estree-util-value-to-estree": "^3.4.0",
     "js-yaml": "^4.1.0",
     "lru-cache": "^11.1.0",
@@ -58,31 +62,37 @@
     "tinyexec": "^1.0.1",
     "tinyglobby": "^0.2.14",
     "unist-util-visit": "^5.0.0",
-    "zod": "^4.0.5"
+    "zod": "^4.0.10"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
+    "@types/node": "^24.1.0",
     "@types/react": "^19.1.8",
     "mdast-util-mdx-jsx": "^3.2.0",
-    "next": "^15.3.5",
+    "next": "^15.4.4",
+    "react": "^19.1.0",
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
-    "vite": "^7.0.4",
-    "webpack": "^5.100.0",
-    "@fumadocs/mdx-remote": "1.3.4",
+    "vite": "^7.0.5",
+    "webpack": "^5.100.2",
+    "@fumadocs/mdx-remote": "1.4.0",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "15.6.3",
+    "fumadocs-core": "15.6.6",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "@fumadocs/mdx-remote": "^1.2.0",
+    "@fumadocs/mdx-remote": "^1.4.0",
     "fumadocs-core": "^14.0.0 || ^15.0.0",
     "next": "^15.3.0",
-    "vite": "6.x.x"
+    "react": "*",
+    "vite": "6.x.x || 7.x.x"
   },
   "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
     "next": {
       "optional": true
     },