fumadocs-mdx 12.0.3 → 13.0.0

package/dist/vite/index.cjs

@@ -173,6 +173,10 @@ var init_build = __esm({
 });
 
 // src/loaders/config/load.ts
+var load_exports = {};
+__export(load_exports, {
+  loadConfig: () => loadConfig
+});
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -193,30 +197,22 @@ async function compileConfig(configPath, outDir) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, outDir, hash, build = false) {
-  if (cache3 && cache3.hash === hash) {
-    return await cache3.config;
-  }
+async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url2.pathToFileURL)(path7.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) cache3 = { config, hash };
+  const url = (0, import_node_url3.pathToFileURL)(path10.resolve(outDir, "source.config.mjs"));
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
   return await config;
 }
-var fs4, path7, import_node_url2, cache3;
+var path10, import_node_url3;
 var init_load = __esm({
   "src/loaders/config/load.ts"() {
     "use strict";
-    fs4 = __toESM(require("fs/promises"), 1);
-    path7 = __toESM(require("path"), 1);
-    import_node_url2 = require("url");
+    path10 = __toESM(require("path"), 1);
+    import_node_url3 = require("url");
     init_build();
-    cache3 = null;
   }
 });
 
@@ -270,142 +266,9 @@ async function validate(schema, data, context, errorMessage) {
 }
 
 // src/vite/index.ts
-var fs6 = __toESM(require("fs/promises"), 1);
-var path9 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 var import_js_yaml2 = require("js-yaml");
 
-// 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);
-  let filename;
-  if (ext === ".ts" && config.jsExtension) {
-    filename = file.substring(0, file.length - ext.length) + ".js";
-  } else if (ext === ".ts") {
-    filename = file.substring(0, file.length - ext.length);
-  } else {
-    filename = 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 importPath.replaceAll(import_node_path.default.sep, "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
-
-// src/vite/generate-glob.ts
-function generateGlob(name, patterns, globOptions) {
-  const options = {
-    ...globOptions,
-    query: {
-      ...globOptions?.query,
-      collection: name
-    }
-  };
-  return `import.meta.glob(${JSON.stringify(mapGlobPatterns(patterns))}, ${JSON.stringify(options, null, 2)})`;
-}
-function mapGlobPatterns(patterns) {
-  return patterns.map(enforceRelative);
-}
-function enforceRelative(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];
-  }
-  return enforceRelative(dir);
-}
-
-// src/utils/collections.ts
-function getSupportedFormats(collection) {
-  return {
-    doc: ["mdx", "md"],
-    meta: ["json", "yaml"]
-  }[collection.type];
-}
-function getGlobPatterns(collection) {
-  if (collection.files) return collection.files;
-  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
-}
-
-// src/vite/generate.ts
-function docs(name, collection) {
-  const obj = [
-    ident(`doc: ${doc(name, collection.docs)}`),
-    ident(`meta: ${meta(name, collection.meta)}`)
-  ].join(",\n");
-  return `{
-${obj}
-}`;
-}
-function doc(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  const docGlob = generateGlob(name, patterns, {
-    base
-  });
-  if (collection.async) {
-    const headBlob = generateGlob(name, patterns, {
-      query: {
-        only: "frontmatter"
-      },
-      import: "frontmatter",
-      base
-    });
-    return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
-  }
-  return `create.doc("${name}", "${base}", ${docGlob})`;
-}
-function meta(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  return `create.meta("${name}", "${base}", ${generateGlob(name, patterns, {
-    import: "default",
-    base
-  })})`;
-}
-function entry(configPath, config, outDir, jsExtension) {
-  const lines = [
-    '/// <reference types="vite/client" />',
-    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
-    `import type * as Config from '${toImportPath(configPath, {
-      relativeTo: outDir,
-      jsExtension
-    })}';`,
-    "",
-    `export const create = fromConfig<typeof Config>();`
-  ];
-  for (const [name, collection] of config.collections.entries()) {
-    let body;
-    if (collection.type === "docs") {
-      body = docs(name, collection);
-    } else if (collection.type === "meta") {
-      body = meta(name, collection);
-    } else {
-      body = doc(name, collection);
-    }
-    lines.push("");
-    lines.push(`export const ${name} = ${body};`);
-  }
-  return lines.join("\n");
-}
-
 // src/utils/fuma-matter.ts
 var import_js_yaml = require("js-yaml");
 var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
@@ -423,7 +286,7 @@ function fumaMatter(input) {
 }
 
 // src/utils/git-timestamp.ts
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var import_tinyexec = require("tinyexec");
 var cache = /* @__PURE__ */ new Map();
 async function getGitTimestamp(file) {
@@ -432,7 +295,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -450,12 +313,56 @@ var import_mdx = require("@mdx-js/mdx");
 
 // src/loaders/mdx/remark-include.ts
 var import_unified = require("unified");
-var import_unist_util_visit = require("unist-util-visit");
-var path3 = __toESM(require("path"), 1);
+var import_unist_util_visit2 = require("unist-util-visit");
+var path2 = __toESM(require("path"), 1);
 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");
+
+// src/loaders/mdx/remark-unravel.ts
+var import_unist_util_visit = require("unist-util-visit");
+function remarkMarkAndUnravel() {
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, function(node, index, parent) {
+      let offset = -1;
+      let all = true;
+      let oneOrMore = false;
+      if (parent && typeof index === "number" && node.type === "paragraph") {
+        const children = node.children;
+        while (++offset < children.length) {
+          const child = children[offset];
+          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
+            oneOrMore = true;
+          } else if (child.type === "text" && child.value.trim().length === 0) {
+          } else {
+            all = false;
+            break;
+          }
+        }
+        if (all && oneOrMore) {
+          offset = -1;
+          const newChildren = [];
+          while (++offset < children.length) {
+            const child = children[offset];
+            if (child.type === "mdxJsxTextElement") {
+              child.type = "mdxJsxFlowElement";
+            }
+            if (child.type === "mdxTextExpression") {
+              child.type = "mdxFlowExpression";
+            }
+            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
+            } else {
+              newChildren.push(child);
+            }
+          }
+          parent.children.splice(index, 1, ...newChildren);
+          return index;
+        }
+      }
+    });
+  };
+}
+
+// src/loaders/mdx/remark-include.ts
 var ElementLikeTypes = [
   "mdxJsxFlowElement",
   "mdxJsxTextElement",
@@ -495,7 +402,7 @@ function parseSpecifier(specifier) {
 function extractSection(root, section) {
   let nodes;
   let capturingHeadingContent = false;
-  (0, import_unist_util_visit.visit)(root, (node) => {
+  (0, import_unist_util_visit2.visit)(root, (node) => {
     if (node.type === "heading") {
       if (capturingHeadingContent) {
         return false;
@@ -527,7 +434,7 @@ function extractSection(root, section) {
 }
 function remarkInclude() {
   const TagName = "include";
-  async function embedContent(file, heading, params, data) {
+  const embedContent = async (file, heading, params, data) => {
     let content;
     try {
       content = (await fs.readFile(file)).toString();
@@ -538,7 +445,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path3.extname(file);
+    const ext = path2.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -550,18 +457,17 @@ ${e instanceof Error ? e.message : String(e)}`,
         data: {}
       };
     }
-    const parser = (data._getProcessor ?? getDefaultProcessor)(
-      ext === ".mdx" ? "mdx" : "md"
-    );
+    const parser = data._getProcessor ? data._getProcessor(ext === ".mdx" ? "mdx" : "md") : this;
     const parsed = fumaMatter(content);
     let mdast = parser.parse({
       path: file,
       value: parsed.content,
       data: { frontmatter: parsed.data }
     });
+    const baseProcessor = (0, import_unified.unified)().use(remarkMarkAndUnravel);
     if (heading) {
       const extracted = extractSection(
-        await (0, import_unified.unified)().use(import_mdx_plugins.remarkHeading).run(mdast),
+        await baseProcessor.use(import_mdx_plugins.remarkHeading).run(mdast),
         heading
       );
       if (!extracted)
@@ -569,20 +475,22 @@ ${e instanceof Error ? e.message : String(e)}`,
           `Cannot find section ${heading} in ${file}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
         );
       mdast = extracted;
+    } else {
+      mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path3.dirname(file), data);
+    await update(mdast, path2.dirname(file), data);
     return mdast;
-  }
+  };
   async function update(tree, directory, data) {
     const queue = [];
-    (0, import_unist_util_visit.visit)(tree, ElementLikeTypes, (_node, _, parent) => {
+    (0, import_unist_util_visit2.visit)(tree, ElementLikeTypes, (_node, _, parent) => {
       const node = _node;
       if (node.name !== TagName) return;
       const specifier = flattenNode(node);
       if (specifier.length === 0) return "skip";
       const attributes = parseElementAttributes(node);
       const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path3.resolve(
+      const file = path2.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -599,27 +507,31 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path3.dirname(file.path), file.data);
+    await update(tree, path2.dirname(file.path), file.data);
   };
 }
-function getDefaultProcessor(format) {
-  const mdProcessor = (0, import_unified.unified)().use(import_remark_parse.default);
-  if (format === "md") return mdProcessor;
-  return mdProcessor.use(import_remark_mdx.default);
-}
 
 // src/loaders/mdx/remark-postprocess.ts
-var import_unist_util_visit2 = require("unist-util-visit");
+var import_unist_util_visit3 = require("unist-util-visit");
 var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
 var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+var import_unist_util_remove_position = require("unist-util-remove-position");
+var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 function remarkPostprocess({
+  _format,
   includeProcessedMarkdown = false,
+  includeMDAST = false,
   valueToExport = []
-} = {}) {
+}) {
+  let _stringifyProcessor;
+  const getStringifyProcessor = () => {
+    if (_format === "mdx") return this;
+    return _stringifyProcessor ??= this().use(import_remark_mdx.default).freeze();
+  };
   return (tree, file) => {
     let title;
     const urls = [];
-    (0, import_unist_util_visit2.visit)(tree, ["heading", "link"], (node) => {
+    (0, import_unist_util_visit3.visit)(tree, ["heading", "link"], (node) => {
       if (node.type === "heading" && node.depth === 1) {
         title = flattenNode2(node);
       }
@@ -635,12 +547,19 @@ function remarkPostprocess({
     }
     file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
+      const processor = getStringifyProcessor();
       file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
-        ...this.data("settings"),
+        ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
-        extensions: this.data("toMarkdownExtensions") || []
+        extensions: processor.data("toMarkdownExtensions") || []
       });
     }
+    if (includeMDAST) {
+      const options = includeMDAST === true ? {} : includeMDAST;
+      file.data._mdast = JSON.stringify(
+        options.removePosition ? (0, import_unist_util_remove_position.removePosition)(structuredClone(tree)) : tree
+      );
+    }
     for (const { name, value } of file.data["mdx-export"] ?? []) {
       tree.children.unshift(getMdastExport(name, value));
     }
@@ -708,6 +627,7 @@ async function buildMDX(cacheKey, source, options) {
           [
             remarkPostprocess,
             {
+              _format: format,
               ...options.postprocess,
               valueToExport: [
                 ...options.postprocess?.valueToExport ?? [],
@@ -715,7 +635,8 @@ async function buildMDX(cacheKey, source, options) {
                 "extractedReferences",
                 "frontmatter",
                 "lastModified",
-                "_markdown"
+                "_markdown",
+                "_mdast"
               ]
             }
           ]
@@ -743,20 +664,25 @@ async function buildMDX(cacheKey, source, options) {
 // src/loaders/mdx/index.ts
 var import_zod = require("zod");
 var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 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()
+  collection: import_zod.z.string().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()
 });
+var hashes = /* @__PURE__ */ new WeakMap();
+function getConfigHash(config) {
+  let hash = hashes.get(config);
+  if (hash) return hash;
+  hash = Date.now().toString();
+  hashes.set(config, hash);
+  return hash;
+}
 function createMdxLoader(configLoader) {
   return async ({
     source: value,
@@ -767,11 +693,11 @@ function createMdxLoader(configLoader) {
   }) => {
     const matter = fumaMatter(value);
     const parsed = querySchema.parse(query);
-    const loaded = await configLoader.getConfig(parsed.hash);
+    const loaded = await configLoader.getConfig();
     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_path3.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      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;
@@ -807,7 +733,7 @@ function createMdxLoader(configLoader) {
     }
     const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
     const compiled = await buildMDX(
-      `${parsed.hash ?? ""}:${parsed.collection ?? "global"}`,
+      `${getConfigHash(loaded)}:${parsed.collection ?? "global"}`,
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
@@ -826,7 +752,7 @@ function createMdxLoader(configLoader) {
     if (cacheDir) {
       await import_promises.default.mkdir(cacheDir, { recursive: true });
       await import_promises.default.writeFile(
-        import_node_path3.default.join(cacheDir, cacheKey),
+        import_node_path2.default.join(cacheDir, cacheKey),
         JSON.stringify({
           ...out,
           hash: generateCacheHash(value)
@@ -848,9 +774,10 @@ function countLines(s) {
 }
 
 // src/loaders/config/index.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 function findConfigFile() {
-  return import_node_path4.default.resolve("source.config.ts");
+  return import_node_path3.default.resolve("source.config.ts");
 }
 function resolvedConfig(loaded) {
   return {
@@ -862,9 +789,9 @@ function resolvedConfig(loaded) {
 
 // src/loaders/adapter.ts
 var import_node_url = require("url");
-var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 function toVite(loader) {
   return async function(file, query, value) {
     const result = await loader({
@@ -885,35 +812,243 @@ function toVite(loader) {
   };
 }
 
-// src/vite/postinstall.ts
-init_load();
-var import_promises3 = __toESM(require("fs/promises"), 1);
+// src/utils/import-formatter.ts
+var import_node_path5 = __toESM(require("path"), 1);
+function toImportPath(file, config) {
+  const ext = import_node_path5.default.extname(file);
+  let filename;
+  if (ext === ".ts" && config.jsExtension) {
+    filename = file.substring(0, file.length - ext.length) + ".js";
+  } else if (ext === ".ts") {
+    filename = file.substring(0, file.length - ext.length);
+  } else {
+    filename = file;
+  }
+  let importPath;
+  if ("relativeTo" in config) {
+    importPath = import_node_path5.default.relative(config.relativeTo, filename);
+    if (!import_node_path5.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+      importPath = `./${importPath}`;
+    }
+  } else {
+    importPath = import_node_path5.default.resolve(filename);
+  }
+  return importPath.replaceAll(import_node_path5.default.sep, "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+// src/utils/collections.ts
+function getSupportedFormats(collection) {
+  return {
+    doc: ["mdx", "md"],
+    meta: ["json", "yaml"]
+  }[collection.type];
+}
+function getGlobPatterns(collection) {
+  if (collection.files) return collection.files;
+  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
+}
+
+// src/utils/glob-import.ts
+var import_tinyglobby = require("tinyglobby");
 var import_node_path6 = __toESM(require("path"), 1);
-async function postInstall(configPath = findConfigFile(), outDir, addJsExtension = false) {
-  const config = await loadConfig(configPath, "node_modules", void 0, true);
-  const outFile = "source.generated.ts";
-  if (outDir) {
-    await import_promises3.default.mkdir(outDir, { recursive: true });
+var import_node_url2 = require("url");
+function generateGlobImport(patterns, options) {
+  let code = "{";
+  const result = (0, import_tinyglobby.globSync)(patterns, {
+    cwd: options.base
+  });
+  for (const item of result) {
+    const fullPath = import_node_path6.default.join(options.base, item);
+    const url = (0, import_node_url2.pathToFileURL)(fullPath);
+    for (const [k, v] of Object.entries(options.query ?? {})) {
+      url.searchParams.set(k, v);
+    }
+    let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(url.href)})`;
+    if (options.import) {
+      line += `.then(mod => mod[${JSON.stringify(options.import)}])`;
+    }
+    code += `${line}, `;
   }
-  await import_promises3.default.writeFile(
-    outDir ? import_node_path6.default.join(outDir, outFile) : outFile,
-    entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
-  );
-  console.log("[MDX] types generated");
+  code += "}";
+  return code;
+}
+
+// src/plugins/vite.ts
+var import_node_path7 = __toESM(require("path"), 1);
+function vite(options) {
+  let config;
+  return {
+    config(v) {
+      config = v;
+    },
+    emit() {
+      console.log("[Fumadocs MDX] Generating index files");
+      return [
+        {
+          path: "index.ts",
+          content: indexFile(this.configPath, this.outDir, config, options)
+        }
+      ];
+    }
+  };
+}
+function indexFile(configPath, outDir, config, options) {
+  const { addJsExtension = false, runtime } = options;
+  const lines = [
+    '/// <reference types="vite/client" />',
+    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
+    `import type * as Config from '${toImportPath(configPath, {
+      relativeTo: outDir,
+      jsExtension: addJsExtension
+    })}';`,
+    "",
+    `export const create = fromConfig<typeof Config>();`
+  ];
+  function docs(name, collection) {
+    const obj = [
+      ident(`doc: ${doc(name, collection.docs)}`),
+      ident(`meta: ${meta(name, collection.meta)}`)
+    ].join(",\n");
+    return `{
+${obj}
+}`;
+  }
+  function doc(name, collection) {
+    const patterns = getGlobPatterns(collection);
+    const base = getGlobBase(collection);
+    const docGlob = generateGlob(patterns, {
+      query: {
+        collection: name
+      },
+      base
+    });
+    if (collection.async) {
+      const headBlob = generateGlob(patterns, {
+        query: {
+          only: "frontmatter",
+          collection: name
+        },
+        import: "frontmatter",
+        base
+      });
+      return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
+    }
+    return `create.doc("${name}", "${base}", ${docGlob})`;
+  }
+  function meta(name, collection) {
+    const patterns = getGlobPatterns(collection);
+    const base = getGlobBase(collection);
+    return `create.meta("${name}", "${base}", ${generateGlob(patterns, {
+      import: "default",
+      base,
+      query: {
+        collection: name
+      }
+    })})`;
+  }
+  function generateGlob(patterns, options2) {
+    patterns = mapGlobPatterns(patterns);
+    if (runtime === "node" || runtime === "bun") {
+      return generateGlobImport(patterns, options2);
+    } else {
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          ...options2,
+          base: import_node_path7.default.relative(outDir, options2.base)
+        },
+        null,
+        2
+      )})`;
+    }
+  }
+  for (const [name, collection] of config.collections.entries()) {
+    let body;
+    if (collection.type === "docs") {
+      body = docs(name, collection);
+    } else if (collection.type === "meta") {
+      body = meta(name, collection);
+    } else {
+      body = doc(name, collection);
+    }
+    lines.push("");
+    lines.push(`export const ${name} = ${body};`);
+  }
+  return lines.join("\n");
+}
+function mapGlobPatterns(patterns) {
+  return patterns.map(enforceRelative);
+}
+function enforceRelative(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];
+  }
+  return enforceRelative(dir);
+}
+
+// src/plugins/index.ts
+var import_node_path8 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+function createPluginHandler(context, defaultPlugins = []) {
+  const plugins2 = [];
+  async function write(entry) {
+    const file = import_node_path8.default.join(context.outDir, entry.path);
+    await import_promises4.default.mkdir(import_node_path8.default.dirname(file), { recursive: true });
+    await import_promises4.default.writeFile(file, entry.content);
+  }
+  return {
+    async init(config) {
+      if (config.global.plugins) {
+        defaultPlugins.push(...config.global.plugins);
+      }
+      for await (const option of defaultPlugins) {
+        if (!option) continue;
+        if (Array.isArray(option)) plugins2.push(...option);
+        else plugins2.push(option);
+      }
+      for (const plugin of plugins2) {
+        const out = await plugin.config?.call(context, config);
+        if (out) config = out;
+      }
+      return config;
+    },
+    async emit() {
+      const out = await Promise.all(
+        plugins2.map((plugin) => {
+          return plugin.emit?.call(context) ?? [];
+        })
+      );
+      return out.flat();
+    },
+    async emitAndWrite() {
+      const entries = await this.emit();
+      await Promise.all(entries.map(write));
+    }
+  };
 }
 
 // src/vite/index.ts
 var FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
-function mdx(config, options = {}) {
-  const {
-    generateIndexFile = true,
-    updateViteConfig = true,
-    configPath = "source.config.ts"
-  } = options;
-  const loaded = buildConfig(config);
+async function mdx(config, pluginOptions = {}) {
+  const options = applyDefaults(pluginOptions);
+  const { updateViteConfig } = options;
+  const pluginHandler = createVitePluginHandler(options);
+  const loaded = await pluginHandler.init(buildConfig(config));
   const mdxLoader = toVite(createMdxLoader(resolvedConfig(loaded)));
-  async function transformMeta(path10, query, value) {
-    const isJson = path10.endsWith(".json");
+  async function transformMeta(path12, query, value) {
+    const isJson = path12.endsWith(".json");
     const parsed = (0, import_node_querystring2.parse)(query);
     const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
     if (!collection) return null;
@@ -936,8 +1071,8 @@ function mdx(config, options = {}) {
     const out = await validate(
       schema,
       data,
-      { path: path10, source: value },
-      `invalid data in ${path10}`
+      { path: path12, source: value },
+      `invalid data in ${path12}`
     );
     return {
       code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
@@ -961,16 +1096,11 @@ function mdx(config, options = {}) {
       });
     },
     async buildStart() {
-      if (!generateIndexFile) return;
-      const { out = "source.generated.ts", addJsExtension } = typeof generateIndexFile === "object" ? generateIndexFile : {};
-      console.log("[Fumadocs MDX] Generating index files");
-      const dir = path9.dirname(out);
-      await fs6.mkdir(dir, { recursive: true });
-      await fs6.writeFile(out, entry(configPath, loaded, dir, addJsExtension));
+      await pluginHandler.emitAndWrite();
     },
     async transform(value, id) {
       const [file, query = ""] = id.split("?");
-      const ext = path9.extname(file);
+      const ext = path11.extname(file);
       try {
         if ([".yaml", ".json"].includes(ext))
           return await transformMeta(file, query, value);
@@ -985,6 +1115,38 @@ function mdx(config, options = {}) {
     }
   };
 }
+async function postInstall(configPath = findConfigFile(), pluginOptions = {}) {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load(), load_exports));
+  const options = applyDefaults(pluginOptions);
+  const pluginHandler = createVitePluginHandler(options);
+  await pluginHandler.init(await loadConfig2(configPath, options.outDir, true));
+  await pluginHandler.emitAndWrite();
+  console.log("[MDX] types generated");
+}
+function createVitePluginHandler({
+  configPath,
+  outDir,
+  generateIndexFile
+}) {
+  return createPluginHandler(
+    {
+      environment: "vite",
+      configPath,
+      outDir
+    },
+    [
+      generateIndexFile !== false && vite(typeof generateIndexFile === "object" ? generateIndexFile : {})
+    ]
+  );
+}
+function applyDefaults(options) {
+  return {
+    updateViteConfig: options.updateViteConfig ?? true,
+    generateIndexFile: options.generateIndexFile ?? true,
+    configPath: options.configPath ?? "source.config.ts",
+    outDir: options.outDir ?? ".source"
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   postInstall