fumadocs-mdx 11.6.11 → 11.7.1

package/dist/vite/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,10 +30,138 @@ 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,
+  remarkNpmOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+        plugins.remarkCodeTab,
+        remarkCodeTabOptions
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...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/vite/index.ts
 var vite_exports = {};
 __export(vite_exports, {
-  default: () => unstable_mdx
+  default: () => mdx
 });
 module.exports = __toCommonJS(vite_exports);
 
@@ -61,11 +192,23 @@ function buildConfig(config) {
       null
     ];
   }
+  let cachedMdxOptions;
   return [
     null,
     {
       global: globalConfig,
-      collections
+      collections,
+      async getDefaultMDXOptions() {
+        if (cachedMdxOptions) return cachedMdxOptions;
+        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 ?? {});
+        }
+        return cachedMdxOptions = uncached();
+      }
     }
   ];
 }
@@ -168,10 +311,10 @@ ${e instanceof Error ? e.message : String(e)}`
 // src/utils/build-mdx.ts
 var cache = /* @__PURE__ */ new Map();
 async function buildMDX(cacheKey, source, options) {
-  const { filePath, frontmatter, data, ...rest } = options;
+  const { filePath, frontmatter, data, _compiler, ...rest } = options;
   let format = options.format;
-  if (!format && filePath) {
-    format = filePath.endsWith(".mdx") ? "mdx" : "md";
+  if (filePath) {
+    format ??= filePath.endsWith(".mdx") ? "mdx" : "md";
   }
   format ??= "mdx";
   const key = `${cacheKey}:${format}`;
@@ -191,7 +334,7 @@ async function buildMDX(cacheKey, source, options) {
     data: {
       ...data,
       frontmatter,
-      _compiler: options._compiler
+      _compiler
     }
   });
 }
@@ -208,166 +351,239 @@ function countLines(s) {
   return num;
 }
 
-// src/utils/mdx-options.ts
-var plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-
-// src/mdx-plugins/remark-exports.ts
-var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
-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)
-                }
-              ]
-            }
-          }
-        ]
-      }
+// src/utils/schema.ts
+var import_zod = require("zod");
+var import_picocolors = __toESM(require("picocolors"), 1);
+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.looseObject({}).optional()
+});
+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;
+  }
+  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/mdx-options.ts
-function pluginOption(def, options = []) {
-  const list = def(Array.isArray(options) ? options : []).filter(
-    Boolean
-  );
-  if (typeof options === "function") {
-    return options(list);
+// src/vite/index.ts
+var import_zod2 = require("zod");
+
+// src/utils/import-formatter.ts
+var import_node_path = __toESM(require("path"), 1);
+function toImportPath(file, config) {
+  const ext = import_node_path.default.extname(file);
+  const filename = ext === ".ts" ? file.substring(0, file.length - ext.length) : file;
+  let importPath;
+  if ("relativeTo" in config) {
+    importPath = import_node_path.default.relative(config.relativeTo, filename);
+    if (!import_node_path.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+      importPath = `./${importPath}`;
+    }
+  } else {
+    importPath = import_node_path.default.resolve(filename);
   }
-  return list;
+  return importPath.replaceAll(import_node_path.default.sep, "/");
 }
-function getDefaultMDXOptions({
-  valueToExport = [],
-  rehypeCodeOptions,
-  remarkImageOptions,
-  remarkHeadingOptions,
-  remarkStructureOptions,
-  remarkCodeTabOptions,
-  remarkNpmOptions,
-  ...mdxOptions
-}) {
-  const mdxExports = [
-    "structuredData",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
-  const remarkPlugins = pluginOption(
-    (v) => [
-      plugins.remarkGfm,
-      [
-        plugins.remarkHeading,
-        {
-          generateToc: false,
-          ...remarkHeadingOptions
-        }
-      ],
-      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
-        plugins.remarkCodeTab,
-        remarkCodeTabOptions
-      ],
-      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
-      ...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
-  );
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+// src/vite/index.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_js_yaml2 = require("js-yaml");
+
+// src/utils/collections.ts
+function getSupportedFormats(collection) {
   return {
-    ...mdxOptions,
-    remarkPlugins,
-    rehypePlugins
-  };
+    doc: ["mdx", "md"],
+    meta: ["json", "yaml"]
+  }[collection.type];
 }
-async function loadDefaultOptions(config) {
-  const input = config.global?.mdxOptions;
-  config._mdx_loader ??= {};
-  const mdxLoader = config._mdx_loader;
-  if (!mdxLoader.cachedOptions) {
-    mdxLoader.cachedOptions = typeof input === "function" ? getDefaultMDXOptions(await input()) : getDefaultMDXOptions(input ?? {});
-  }
-  return mdxLoader.cachedOptions;
+function getGlobPatterns(collection) {
+  if (collection.files) return collection.files;
+  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
 }
 
 // src/vite/index.ts
 var fileRegex = /\.(md|mdx)$/;
-function unstable_mdx(config, _options = {}) {
+var onlySchema = import_zod2.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 import_promises.default.writeFile(import_node_path2.default.join(outdir, outFile), lines.join("\n"));
+    },
     async transform(value, id) {
-      const [path2, query = ""] = id.split("?");
-      if (!fileRegex.test(path2)) return;
+      const [path4, query = ""] = id.split("?");
+      const isJson = path4.endsWith(".json");
+      const isYaml = path4.endsWith(".yaml");
+      if (isJson || isYaml) {
+        const parsed2 = (0, import_node_querystring.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) : (0, import_js_yaml2.load)(value);
+        } catch {
+          return null;
+        }
+        const out = await validate(
+          schema2,
+          data,
+          { path: path4, source: value },
+          `invalid data in ${path4}`
+        );
+        return {
+          code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
+          map: null
+        };
+      }
+      if (!fileRegex.test(path4)) return;
       const matter = fumaMatter(value);
       const isDevelopment = this.environment.mode === "dev";
-      const { collection: collectionId, raw } = (0, import_node_querystring.parse)(query);
-      const collection = collectionId ? loaded.collections.get(collectionId) : void 0;
-      const lineOffset = "\n".repeat(
-        isDevelopment ? countLines(matter.matter) : 0
-      );
+      const parsed = (0, import_node_querystring.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: path4
+            },
+            `invalid frontmatter in ${path4}`
+          );
+        } 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: path2,
+          filePath: path4,
           frontmatter: matter.data,
           _compiler: {
             addDependency: (file2) => {
@@ -377,8 +593,43 @@ 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;
+}

package/dist/vite/index.d.cts

@@ -1,8 +1,17 @@
 import { Plugin } from 'vite';
 
-interface CreateMDXOptions {
+interface PluginOptions {
+    /**
+     * Automatically generate index files for accessing files with `import.meta.glob`.
+     *
+     * @defaultValue true
+     */
+    generateIndexFile?: boolean;
+    /**
+     * @defaultValue source.config.ts
+     */
     configPath?: string;
 }
-declare function unstable_mdx(config: Record<string, unknown>, _options?: CreateMDXOptions): Plugin;
+declare function mdx(config: Record<string, unknown>, options?: PluginOptions): Plugin;
 
-export { type CreateMDXOptions, unstable_mdx as default };
+export { type PluginOptions, mdx as default };

package/dist/vite/index.d.ts

@@ -1,8 +1,17 @@
 import { Plugin } from 'vite';
 
-interface CreateMDXOptions {
+interface PluginOptions {
+    /**
+     * Automatically generate index files for accessing files with `import.meta.glob`.
+     *
+     * @defaultValue true
+     */
+    generateIndexFile?: boolean;
+    /**
+     * @defaultValue source.config.ts
+     */
     configPath?: string;
 }
-declare function unstable_mdx(config: Record<string, unknown>, _options?: CreateMDXOptions): Plugin;
+declare function mdx(config: Record<string, unknown>, options?: PluginOptions): Plugin;
 
-export { type CreateMDXOptions, unstable_mdx as default };
+export { type PluginOptions, mdx as default };