fumadocs-mdx 11.6.10 → 11.7.0

package/dist/vite/index.js

@@ -1,57 +1,212 @@
 import {
   buildMDX,
   countLines
-} from "../chunk-6PDS7MUA.js";
+} from "../chunk-C5INPAZJ.js";
 import {
-  loadDefaultOptions
-} from "../chunk-64MMPGML.js";
-import "../chunk-AVMO2SRO.js";
+  toImportPath
+} from "../chunk-JPPCALFT.js";
 import {
   buildConfig
-} from "../chunk-DRVUBK5B.js";
+} from "../chunk-GWR7KMRU.js";
+import {
+  ValidationError,
+  validate
+} from "../chunk-ZOWJF3OH.js";
+import "../chunk-AVMO2SRO.js";
 import {
   fumaMatter
 } from "../chunk-KVWX6THC.js";
 
 // 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 filesToGlob(files) {
+        return files.map((file) => {
+          if (file.startsWith("./")) return file;
+          if (file.startsWith("/")) return `.${file}`;
+          return `./${file}`;
+        });
+      }
+      function docs(name, dir, collection) {
+        const docFiles = collection.docs.files ? filesToGlob(collection.docs.files) : ["./**/*.{mdx,md}"];
+        const metaFiles = collection.meta.files ? filesToGlob(collection.meta.files) : ["./**/*.{yaml,json}"];
+        return `export const ${name} = create.docs('${name}', {
+  doc: import.meta.glob(${JSON.stringify(docFiles)}, {
+    query: {
+      collection: '${name}',
+    },
+    base: '${dir}',
+  }),
+  meta: import.meta.glob(${JSON.stringify(metaFiles)}, {
+    query: {
+      collection: '${name}',
+    },
+    base: '${dir}',
+    import: 'default',
+  }),
+});`;
+      }
+      function doc(name, dir, collection) {
+        const files = collection.files ? filesToGlob(collection.files) : ["./**/*.{mdx,md}"];
+        return `export const ${name} = create.doc(
+  '${name}',
+  import.meta.glob(${JSON.stringify(files)}, {
+    query: {
+      collection: '${name}',
+    },
+    base: '${dir}',
+  }),
+);`;
+      }
+      function meta(name, dir, collection) {
+        const files = collection.files ? filesToGlob(collection.files) : ["./**/*.{yaml,json}"];
+        return `export const ${name} = create.meta(
+  '${name}',
+  import.meta.glob(${JSON.stringify(files)}, {
+    query: {
+      collection: '${name}',
+    },
+    base: '${dir}',
+    import: 'default',
+  }),
+);`;
+      }
+      for (const [name, collection] of loaded.collections.entries()) {
+        let dir = collection.dir;
+        if (Array.isArray(dir) && dir.length === 1) {
+          dir = dir[0];
+        } else if (Array.isArray(dir)) {
+          throw new Error(
+            `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
+          );
+        }
+        if (!dir.startsWith("./") && !dir.startsWith("/")) {
+          dir = "/" + dir;
+        }
+        lines.push("");
+        if (collection.type === "docs") {
+          lines.push(docs(name, dir, collection));
+        } else if (collection.type === "meta") {
+          lines.push(meta(name, dir, collection));
+        } else {
+          lines.push(doc(name, dir, 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 +216,12 @@ 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
       };
     }
   };
 }
 export {
-  unstable_mdx as default
+  mdx as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "11.6.10",
+  "version": "11.7.0",
   "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.5",
+    "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": "^3.25.67"
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
+    "@types/node": "^24.0.15",
     "@types/react": "^19.1.8",
     "mdast-util-mdx-jsx": "^3.2.0",
-    "next": "^15.3.4",
+    "next": "^15.4.2",
+    "react": "^19.1.0",
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
-    "vite": "^7.0.0",
-    "webpack": "^5.99.9",
-    "@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.0",
+    "fumadocs-core": "15.6.5",
     "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
     },

package/dist/types-DvTNxAvo.d.cts

@@ -1,217 +0,0 @@
-import { MDXProps } from 'mdx/types';
-import * as plugins from 'fumadocs-core/mdx-plugins';
-import { StructuredData } from 'fumadocs-core/mdx-plugins';
-import { TableOfContents } from 'fumadocs-core/server';
-import { ProcessorOptions } from '@mdx-js/mdx';
-import { Pluggable } from 'unified';
-import { FC } from 'react';
-import { z } from 'zod';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { MDXOptions as MDXOptions$1 } from '@fumadocs/mdx-remote';
-
-interface MDXOptions extends ProcessorOptions {
-    /**
-     * Name of collection
-     */
-    collection?: string;
-    /**
-     * Specify a file path for source
-     */
-    filePath?: string;
-    frontmatter?: Record<string, unknown>;
-    /**
-     * Custom Vfile data
-     */
-    data?: Record<string, unknown>;
-    _compiler?: CompilerOptions;
-}
-interface CompilerOptions {
-    addDependency: (file: string) => void;
-}
-declare module 'vfile' {
-    interface DataMap {
-        /**
-         * The compiler object from loader
-         */
-        _compiler?: CompilerOptions;
-    }
-}
-
-declare const metaSchema: z.ZodObject<{
-    title: z.ZodOptional<z.ZodString>;
-    pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    description: z.ZodOptional<z.ZodString>;
-    root: z.ZodOptional<z.ZodBoolean>;
-    defaultOpen: z.ZodOptional<z.ZodBoolean>;
-    icon: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    root?: boolean | undefined;
-    title?: string | undefined;
-    pages?: string[] | undefined;
-    description?: string | undefined;
-    defaultOpen?: boolean | undefined;
-    icon?: string | undefined;
-}, {
-    root?: boolean | undefined;
-    title?: string | undefined;
-    pages?: string[] | undefined;
-    description?: string | undefined;
-    defaultOpen?: boolean | undefined;
-    icon?: string | undefined;
-}>;
-declare const frontmatterSchema: z.ZodObject<{
-    title: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    icon: z.ZodOptional<z.ZodString>;
-    full: z.ZodOptional<z.ZodBoolean>;
-    _openapi: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-}, "strip", z.ZodTypeAny, {
-    title: string;
-    description?: string | undefined;
-    icon?: string | undefined;
-    full?: boolean | undefined;
-    _openapi?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-}, {
-    title: string;
-    description?: string | undefined;
-    icon?: string | undefined;
-    full?: boolean | undefined;
-    _openapi?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-}>;
-
-type CollectionSchema<Schema extends StandardSchemaV1, Context> = Schema | ((ctx: Context) => Schema);
-interface BaseCollection {
-    /**
-     * Directories to scan
-     */
-    dir: string | string[];
-    /**
-     * what files to include/exclude (glob patterns)
-     *
-     * Include all files if not specified
-     */
-    files?: string[];
-}
-interface MetaCollection<Schema extends StandardSchemaV1 = StandardSchemaV1> extends BaseCollection {
-    type: 'meta';
-    schema?: CollectionSchema<Schema, {
-        path: string;
-        source: string;
-    }>;
-}
-interface DocCollection<Schema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> extends BaseCollection {
-    type: 'doc';
-    mdxOptions?: MDXOptions;
-    /**
-     * Load files with async
-     */
-    async?: Async;
-    schema?: CollectionSchema<Schema, {
-        path: string;
-        source: string;
-    }>;
-}
-interface DocsCollection<DocSchema extends StandardSchemaV1 = StandardSchemaV1, MetaSchema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> {
-    type: 'docs';
-    dir: string | string[];
-    docs: DocCollection<DocSchema, Async>;
-    meta: MetaCollection<MetaSchema>;
-}
-declare function defineCollections<T extends 'doc' | 'meta', Schema extends StandardSchemaV1 = StandardSchemaV1<unknown, any>, Async extends boolean = false>(options: {
-    type: T;
-} & (T extends 'doc' ? DocCollection<Schema, Async> : MetaCollection<Schema>)): {
-    type: T;
-    _type: {
-        async: Async;
-        schema: Schema;
-    };
-};
-declare function defineDocs<DocSchema extends StandardSchemaV1 = typeof frontmatterSchema, MetaSchema extends StandardSchemaV1 = typeof metaSchema, Async extends boolean = false>(options?: {
-    /**
-     * The directory to scan files
-     *
-     *  @defaultValue 'content/docs'
-     */
-    dir?: string | string[];
-    docs?: Omit<DocCollection<DocSchema, Async>, 'dir' | 'type'>;
-    meta?: Omit<MetaCollection<MetaSchema>, 'dir' | 'type'>;
-}): {
-    type: 'docs';
-    docs: {
-        type: 'doc';
-        _type: {
-            schema: DocSchema;
-            async: Async;
-        };
-    };
-    meta: {
-        type: 'meta';
-        _type: {
-            schema: MetaSchema;
-            async: false;
-        };
-    };
-};
-declare function defineConfig(config?: GlobalConfig): GlobalConfig;
-
-interface LoadedConfig {
-    collections: Map<string, DocCollection | MetaCollection | DocsCollection>;
-    global?: GlobalConfig;
-    _mdx_loader?: {
-        cachedOptions?: ProcessorOptions;
-    };
-    _mdx_async?: {
-        cachedMdxOptions?: MDXOptions$1;
-    };
-}
-
-type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
-type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
-    rehypePlugins?: ResolvePlugins;
-    remarkPlugins?: ResolvePlugins;
-    /**
-     * Properties to export from `vfile.data`
-     */
-    valueToExport?: string[];
-    remarkStructureOptions?: plugins.StructureOptions | false;
-    remarkHeadingOptions?: plugins.RemarkHeadingOptions;
-    remarkImageOptions?: plugins.RemarkImageOptions | false;
-    remarkCodeTabOptions?: plugins.RemarkCodeTabOptions | false;
-    remarkNpmOptions?: plugins.RemarkNpmOptions | false;
-    rehypeCodeOptions?: plugins.RehypeCodeOptions | false;
-};
-declare function loadDefaultOptions(config: LoadedConfig): Promise<ProcessorOptions>;
-
-interface GlobalConfig {
-    /**
-     * Configure global MDX options
-     */
-    mdxOptions?: DefaultMDXOptions | (() => DefaultMDXOptions | Promise<DefaultMDXOptions>);
-    /**
-     * Fetch last modified time with specified version control
-     * @defaultValue 'none'
-     */
-    lastModifiedTime?: 'git' | 'none';
-}
-interface FileInfo {
-    path: string;
-    absolutePath: string;
-}
-interface MarkdownProps {
-    body: FC<MDXProps>;
-    structuredData: StructuredData;
-    toc: TableOfContents;
-    _exports: Record<string, unknown>;
-    /**
-     * Only available when `lastModifiedTime` is enabled on MDX loader
-     */
-    lastModified?: Date;
-}
-interface BaseCollectionEntry {
-    /**
-     * Raw file path of collection entry, including absolute path (not normalized).
-     */
-    _file: FileInfo;
-}
-
-export { type BaseCollectionEntry as B, type CollectionSchema as C, type DefaultMDXOptions as D, type FileInfo as F, type GlobalConfig as G, type LoadedConfig as L, type MarkdownProps as M, type BaseCollection as a, type MetaCollection as b, type DocCollection as c, type DocsCollection as d, defineCollections as e, frontmatterSchema as f, defineDocs as g, defineConfig as h, loadDefaultOptions as l, metaSchema as m };