fumadocs-mdx 13.0.2 → 13.0.4

package/dist/bin.cjs

@@ -30,19 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/loaders/config/index.ts
-function findConfigFile() {
-  return import_node_path.default.resolve("source.config.ts");
-}
-var import_node_path, import_promises;
-var init_config = __esm({
-  "src/loaders/config/index.ts"() {
-    "use strict";
-    import_node_path = __toESM(require("path"), 1);
-    import_promises = __toESM(require("fs/promises"), 1);
-  }
-});
-
 // src/loaders/mdx/preset.ts
 var preset_exports = {};
 __export(preset_exports, {
@@ -131,35 +118,78 @@ var init_preset = __esm({
 });
 
 // src/config/build.ts
+function buildCollection(name, config) {
+  if (config.type === "docs") {
+    return {
+      ...config,
+      name,
+      meta: buildPrimitiveCollection(name, config.meta),
+      docs: buildPrimitiveCollection(name, config.docs)
+    };
+  }
+  return buildPrimitiveCollection(name, config);
+}
+function buildPrimitiveCollection(name, { files, ...config }) {
+  const supportedFormats = SupportedFormats[config.type];
+  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matchers;
+  return {
+    ...config,
+    name,
+    patterns,
+    isFileSupported(filePath) {
+      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+    },
+    hasFile(filePath) {
+      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
+        (dir) => (0, import_picomatch.default)(patterns, {
+          cwd: dir
+        })
+      );
+      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+    }
+  };
+}
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
-  let globalConfig = {};
+  const loaded = {};
   for (const [k, v] of Object.entries(config)) {
     if (!v) {
       continue;
     }
     if (typeof v === "object" && "type" in v) {
       if (v.type === "docs") {
-        collections.set(k, v);
+        collections.set(k, buildCollection(k, v));
         continue;
       }
       if (v.type === "doc" || v.type === "meta") {
-        collections.set(k, v);
+        collections.set(
+          k,
+          buildCollection(k, v)
+        );
         continue;
       }
     }
     if (k === "default" && v) {
-      globalConfig = v;
+      Object.assign(loaded, v);
       continue;
     }
     throw new Error(
       `Unknown export "${k}", you can only export collections from source configuration file.`
     );
   }
+  if (loaded.collections) {
+    for (const [k, v] of Object.entries(loaded.collections)) {
+      collections.set(k, buildCollection(k, v));
+    }
+  }
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
-    global: globalConfig,
-    collections,
+    global: loaded,
+    collectionList: Array.from(collections.values()),
+    getCollection(name) {
+      return collections.get(name);
+    },
     async getDefaultMDXOptions(mode = "default") {
       const cached = mdxOptionsCache.get(mode);
       if (cached) return cached;
@@ -179,15 +209,21 @@ function buildConfig(config) {
     }
   };
 }
+var import_picomatch, SupportedFormats;
 var init_build = __esm({
   "src/config/build.ts"() {
     "use strict";
+    import_picomatch = __toESM(require("picomatch"), 1);
+    SupportedFormats = {
+      doc: ["mdx", "md"],
+      meta: ["json", "yaml"]
+    };
   }
 });
 
-// src/loaders/config/load.ts
-var load_exports = {};
-__export(load_exports, {
+// src/config/load-from-file.ts
+var load_from_file_exports = {};
+__export(load_from_file_exports, {
   loadConfig: () => loadConfig
 });
 async function compileConfig(configPath, outDir) {
@@ -212,18 +248,18 @@ async function compileConfig(configPath, outDir) {
 }
 async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path2.resolve(outDir, "source.config.mjs"));
+  const url = (0, import_node_url.pathToFileURL)(path.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 path2, import_node_url;
-var init_load = __esm({
-  "src/loaders/config/load.ts"() {
+var path, import_node_url;
+var init_load_from_file = __esm({
+  "src/config/load-from-file.ts"() {
     "use strict";
-    path2 = __toESM(require("path"), 1);
+    path = __toESM(require("path"), 1);
     import_node_url = require("url");
     init_build();
   }
@@ -231,8 +267,8 @@ var init_load = __esm({
 
 // src/next/file-cache.ts
 function toFullPath(file) {
-  if (import_node_path2.default.isAbsolute(file)) {
-    return import_node_path2.default.relative(process.cwd(), file);
+  if (import_node_path.default.isAbsolute(file)) {
+    return import_node_path.default.relative(process.cwd(), file);
   }
   return file;
 }
@@ -240,20 +276,20 @@ async function readFileWithCache(file) {
   const fullPath = toFullPath(file);
   const cached = map.get(fullPath);
   if (cached) return cached;
-  const read = import_promises2.default.readFile(fullPath).then((s) => s.toString());
+  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
   map.set(fullPath, read);
   return read;
 }
 function removeFileCache(file) {
   map.delete(toFullPath(file));
 }
-var import_lru_cache, import_promises2, import_node_path2, map;
+var import_lru_cache, import_promises, import_node_path, map;
 var init_file_cache = __esm({
   "src/next/file-cache.ts"() {
     "use strict";
     import_lru_cache = require("lru-cache");
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    import_node_path2 = __toESM(require("path"), 1);
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_node_path = __toESM(require("path"), 1);
     map = new import_lru_cache.LRUCache({
       max: 100
     });
@@ -311,7 +347,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path3.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -323,11 +359,11 @@ async function getGitTimestamp(file) {
     return;
   }
 }
-var import_node_path3, import_tinyexec, cache;
+var import_node_path2, import_tinyexec, cache;
 var init_git_timestamp = __esm({
   "src/utils/git-timestamp.ts"() {
     "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
     import_tinyexec = require("tinyexec");
     cache = /* @__PURE__ */ new Map();
   }
@@ -370,7 +406,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path4.default.extname(file);
+  const ext = import_node_path3.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -381,68 +417,23 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path4.default.relative(config.relativeTo, filename);
-    if (!import_node_path4.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path3.default.relative(config.relativeTo, filename);
+    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path4.default.resolve(filename);
+    importPath = import_node_path3.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path4.default.sep, "/");
+  return importPath.replaceAll(import_node_path3.default.sep, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_node_path4;
+var import_node_path3;
 var init_import_formatter = __esm({
   "src/utils/import-formatter.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
-  }
-});
-
-// src/utils/collections.ts
-function getGlobPatterns(collection) {
-  if (collection.files) return collection.files;
-  return [`**/*.{${SupportedFormats[collection.type].join(",")}}`];
-}
-function isFileSupported(filePath, collection) {
-  return SupportedFormats[collection.type].some(
-    (format) => filePath.endsWith(`.${format}`)
-  );
-}
-async function getCollectionFiles(collection) {
-  const files = /* @__PURE__ */ new Map();
-  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-  const patterns = getGlobPatterns(collection);
-  await Promise.all(
-    dirs.map(async (dir) => {
-      const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: import_node_path5.default.resolve(dir)
-      });
-      for (const item of result) {
-        if (!isFileSupported(item, collection)) continue;
-        const fullPath = import_node_path5.default.join(dir, item);
-        files.set(fullPath, {
-          path: item,
-          fullPath
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
-}
-var import_picomatch, import_tinyglobby, import_node_path5, SupportedFormats;
-var init_collections = __esm({
-  "src/utils/collections.ts"() {
-    "use strict";
-    import_picomatch = __toESM(require("picomatch"), 1);
-    import_tinyglobby = require("tinyglobby");
-    import_node_path5 = __toESM(require("path"), 1);
-    SupportedFormats = {
-      doc: ["mdx", "md"],
-      meta: ["json", "yaml"]
-    };
+    import_node_path3 = __toESM(require("path"), 1);
   }
 });
 
@@ -454,17 +445,14 @@ function next() {
     name: "next",
     config(v) {
       config = v;
-      shouldEmitOnChange = false;
-      for (const collection of config.collections.values()) {
-        if (collection.type === "doc" && collection.async || collection.type === "docs" && collection.docs.async) {
-          shouldEmitOnChange = true;
-        }
-      }
+      shouldEmitOnChange = config.collectionList.some((collection) => {
+        return collection.type === "doc" && collection.async || collection.type === "docs" || collection.type === "meta";
+      });
     },
     configureServer(server) {
       if (!server.watcher) return;
-      server.watcher.on("all", async () => {
-        if (!shouldEmitOnChange) return;
+      server.watcher.on("all", async (event) => {
+        if (event === "change" && !shouldEmitOnChange) return;
         await this.core.emitAndWrite({
           filterPlugin: (plugin) => plugin.name === "next"
         });
@@ -482,7 +470,7 @@ function next() {
     }
   };
 }
-async function indexFile(configPath, config, importPath, configHash = false) {
+async function indexFile(configPath, config, importPath) {
   let asyncInit = false;
   const lines = [
     getImportCode({
@@ -496,14 +484,10 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       name: "_source"
     })
   ];
-  const entries = Array.from(config.collections.entries());
-  async function getDocEntries(collectionName, files) {
-    const items = files.map(async (file, i) => {
-      const importId = `${collectionName}_${i}`;
-      const params = [`collection=${collectionName}`];
-      if (configHash) {
-        params.push(`hash=${configHash}`);
-      }
+  function getDocEntries(collection, files) {
+    return files.map((file, i) => {
+      const importId = `d_${collection.name}_${i}`;
+      const params = [`collection=${collection.name}`];
       lines.unshift(
         getImportCode({
           type: "namespace",
@@ -513,7 +497,6 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
     });
-    return Promise.all(items);
   }
   async function getMetaEntries(collection, files) {
     const items = files.map(async (file) => {
@@ -554,7 +537,7 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       asyncInit = true;
     }
-    const entries2 = files.map(async (file) => {
+    const entries = files.map(async (file) => {
       const content = await readFileWithCache(file.fullPath).catch(() => "");
       const parsed = fumaMatter(content);
       let data = parsed.data;
@@ -580,12 +563,13 @@ async function indexFile(configPath, config, importPath, configHash = false) {
       );
       return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
     });
-    return Promise.all(entries2);
+    return Promise.all(entries);
   }
-  const declares = entries.map(async ([k, collection]) => {
+  const declares = config.collectionList.map(async (collection) => {
+    const k = collection.name;
     if (collection.type === "docs") {
-      const docs = await getCollectionFiles(collection.docs);
-      const metas = await getCollectionFiles(collection.meta);
+      const docs = await globCollectionFiles(collection.docs);
+      const metas = await globCollectionFiles(collection.meta);
       const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
@@ -595,14 +579,17 @@ async function indexFile(configPath, config, importPath, configHash = false) {
         );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getDocEntries(k, docs)).join(", ");
+      const docsEntries = getDocEntries(collection.docs, docs).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
-    const files = await getCollectionFiles(collection);
-    if (collection.type === "doc" && collection.async) {
+    const files = await globCollectionFiles(collection);
+    if (collection.type === "meta") {
+      return `export const ${k} = _runtime.meta<typeof _source.${k}>([${(await getMetaEntries(collection, files)).join(", ")}]);`;
+    }
+    if (collection.async) {
       return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.doc<typeof _source.${k}>([${getDocEntries(collection, files).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -612,34 +599,57 @@ async function indexFile(configPath, config, importPath, configHash = false) {
   ].join("\n");
 }
 function parseMetaEntry(file, content) {
-  const extname4 = path7.extname(file);
+  const extname3 = path5.extname(file);
   try {
-    if (extname4 === ".json") return JSON.parse(content);
-    if (extname4 === ".yaml") return (0, import_js_yaml2.load)(content);
+    if (extname3 === ".json") return JSON.parse(content);
+    if (extname3 === ".yaml") return (0, import_js_yaml2.load)(content);
   } catch (e) {
     throw new Error(`Failed to parse meta file: ${file}.`, {
       cause: e
     });
   }
-  throw new Error(`Unknown meta file format: ${extname4}, in ${file}.`);
+  throw new Error(`Unknown meta file format: ${extname3}, in ${file}.`);
 }
-var path7, import_node_crypto, import_js_yaml2;
+async function globCollectionFiles(collection) {
+  const { glob } = await import("tinyglobby");
+  const files = /* @__PURE__ */ new Map();
+  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+  await Promise.all(
+    dirs.map(async (dir) => {
+      const result = await glob(collection.patterns, {
+        cwd: path5.resolve(dir)
+      });
+      for (const item of result) {
+        if (!collection.isFileSupported(item)) continue;
+        const fullPath = path5.join(dir, item);
+        files.set(fullPath, {
+          path: item,
+          fullPath
+        });
+      }
+    })
+  );
+  return Array.from(files.values());
+}
+var path5, import_node_crypto, import_js_yaml2;
 var init_next = __esm({
   "src/plugins/next.ts"() {
     "use strict";
-    path7 = __toESM(require("path"), 1);
+    path5 = __toESM(require("path"), 1);
     import_node_crypto = require("crypto");
     init_validation();
     init_file_cache();
-    import_js_yaml2 = require("js-yaml");
     init_git_timestamp();
     init_fuma_matter();
     init_import_formatter();
-    init_collections();
+    import_js_yaml2 = require("js-yaml");
   }
 });
 
 // src/core.ts
+function findConfigFile() {
+  return import_node_path4.default.resolve("source.config.ts");
+}
 function createCore(options, defaultPlugins = []) {
   let config;
   let plugins2;
@@ -676,13 +686,6 @@ function createCore(options, defaultPlugins = []) {
     getConfig() {
       return config;
     },
-    creatConfigLoader() {
-      return {
-        getConfig() {
-          return config;
-        }
-      };
-    },
     async initServer(server) {
       for (const plugin of plugins2) {
         await plugin.configureServer?.call(this.getPluginContext(), server);
@@ -700,21 +703,31 @@ function createCore(options, defaultPlugins = []) {
       );
       await Promise.all(
         out.flat().map(async (entry) => {
-          const file = import_node_path6.default.join(options.outDir, entry.path);
-          await import_promises3.default.mkdir(import_node_path6.default.dirname(file), { recursive: true });
-          await import_promises3.default.writeFile(file, entry.content);
+          const file = import_node_path4.default.join(options.outDir, entry.path);
+          await import_promises2.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
+          await import_promises2.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start2}ms`);
     }
   };
 }
-var import_node_path6, import_promises3;
+var import_node_path4, import_promises2;
 var init_core = __esm({
   "src/core.ts"() {
     "use strict";
-    import_node_path6 = __toESM(require("path"), 1);
-    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
+  }
+});
+
+// src/loaders/index.ts
+var metaLoaderGlob, mdxLoaderGlob;
+var init_loaders = __esm({
+  "src/loaders/index.ts"() {
+    "use strict";
+    metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+    mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
   }
 });
 
@@ -732,7 +745,7 @@ function createMDX(createOptions = {}) {
     void init(isDev, options);
   }
   return (nextConfig = {}) => {
-    const mdxLoaderOptions = {
+    const loaderOptions = {
       ...options,
       isDev
     };
@@ -744,7 +757,7 @@ function createMDX(createOptions = {}) {
           loaders: [
             {
               loader: "fumadocs-mdx/loader-mdx",
-              options: mdxLoaderOptions
+              options: loaderOptions
             }
           ],
           as: "*.js"
@@ -760,12 +773,12 @@ function createMDX(createOptions = {}) {
         config.module ||= {};
         config.module.rules ||= [];
         config.module.rules.push({
-          test: /\.mdx?$/,
+          test: mdxLoaderGlob,
           use: [
             options2.defaultLoaders.babel,
             {
               loader: "fumadocs-mdx/loader-mdx",
-              options: mdxLoaderOptions
+              options: loaderOptions
             }
           ]
         });
@@ -791,7 +804,7 @@ async function init(dev, options) {
       ignored: [options.outDir]
     });
     watcher.add(options.configPath);
-    for (const collection of core.getConfig().collections.values()) {
+    for (const collection of core.getConfig().collectionList) {
       if (collection.type === "docs") {
         watcher.add(collection.docs.dir);
         watcher.add(collection.meta.dir);
@@ -803,9 +816,9 @@ async function init(dev, options) {
       console.log("[MDX] started dev server");
     });
     watcher.on("all", async (event, file) => {
-      const absolutePath = path9.resolve(file);
+      const absolutePath = path7.resolve(file);
       if (event === "change") removeFileCache(absolutePath);
-      if (absolutePath === path9.resolve(options.configPath)) {
+      if (absolutePath === path7.resolve(options.configPath)) {
         watcher.removeAllListeners();
         await watcher.close();
         await initOrReload();
@@ -867,17 +880,17 @@ function createNextCore({
     }
   };
 }
-var path9, defaultPageExtensions;
+var path7, defaultPageExtensions;
 var init_next2 = __esm({
   "src/next/index.ts"() {
     "use strict";
-    init_config();
-    path9 = __toESM(require("path"), 1);
-    init_load();
+    path7 = __toESM(require("path"), 1);
+    init_load_from_file();
     init_file_cache();
     init_validation();
     init_next();
     init_core();
+    init_loaders();
     defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
   }
 });
@@ -1000,7 +1013,7 @@ function remarkInclude() {
   const embedContent = async (file, heading, params, data) => {
     let content;
     try {
-      content = (await fs4.readFile(file)).toString();
+      content = (await fs3.readFile(file)).toString();
     } catch (e) {
       throw new Error(
         `failed to read file ${file}
@@ -1008,7 +1021,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path10.extname(file);
+    const ext = path8.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -1041,7 +1054,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path10.dirname(file), data);
+    await update(mdast, path8.dirname(file), data);
     return mdast;
   };
   async function update(tree, directory, data) {
@@ -1053,7 +1066,7 @@ ${e instanceof Error ? e.message : String(e)}`,
       if (specifier.length === 0) return "skip";
       const attributes = parseElementAttributes(node);
       const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path10.resolve(
+      const file = path8.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -1070,17 +1083,17 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path10.dirname(file.path), file.data);
+    await update(tree, path8.dirname(file.path), file.data);
   };
 }
-var import_unified, import_unist_util_visit2, path10, fs4, import_mdx_plugins, ElementLikeTypes;
+var import_unified, import_unist_util_visit2, path8, fs3, import_mdx_plugins, ElementLikeTypes;
 var init_remark_include = __esm({
   "src/loaders/mdx/remark-include.ts"() {
     "use strict";
     import_unified = require("unified");
     import_unist_util_visit2 = require("unist-util-visit");
-    path10 = __toESM(require("path"), 1);
-    fs4 = __toESM(require("fs/promises"), 1);
+    path8 = __toESM(require("path"), 1);
+    fs3 = __toESM(require("fs/promises"), 1);
     init_fuma_matter();
     import_mdx_plugins = require("fumadocs-core/mdx-plugins");
     init_remark_unravel();
@@ -1275,12 +1288,12 @@ function createMdxLoader(configLoader) {
     if (!isDevelopment && config.global.experimentalBuildCache) {
       const cacheDir = config.global.experimentalBuildCache;
       const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
-      const cached = await import_promises4.default.readFile(import_node_path7.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      const cached = await import_promises3.default.readFile(import_node_path5.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
       if (cached && cached.hash === generateCacheHash(value)) return cached;
       after = async () => {
-        await import_promises4.default.mkdir(cacheDir, { recursive: true });
-        await import_promises4.default.writeFile(
-          import_node_path7.default.join(cacheDir, cacheKey),
+        await import_promises3.default.mkdir(cacheDir, { recursive: true });
+        await import_promises3.default.writeFile(
+          import_node_path5.default.join(cacheDir, cacheKey),
           JSON.stringify({
             ...out,
             hash: generateCacheHash(value)
@@ -1288,7 +1301,7 @@ function createMdxLoader(configLoader) {
         );
       };
     }
-    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.getCollection(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -1358,7 +1371,7 @@ function countLines(s) {
   }
   return num;
 }
-var import_zod, import_promises4, import_node_path7, import_node_crypto2, querySchema, cacheEntry, hashes;
+var import_zod, import_promises3, import_node_path5, import_node_crypto2, querySchema, cacheEntry, hashes;
 var init_mdx = __esm({
   "src/loaders/mdx/index.ts"() {
     "use strict";
@@ -1367,8 +1380,8 @@ var init_mdx = __esm({
     init_git_timestamp();
     init_build_mdx();
     import_zod = require("zod");
-    import_promises4 = __toESM(require("fs/promises"), 1);
-    import_node_path7 = __toESM(require("path"), 1);
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     querySchema = import_zod.z.object({
       only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
@@ -1397,32 +1410,33 @@ function toVite(loader) {
         }
       }
     });
+    if (result === null) return null;
     return {
       code: result.code,
       map: result.map
     };
   };
 }
-var import_node_url2, import_promises5, import_node_querystring, import_node_path8;
+var import_node_url2, import_promises4, import_node_querystring, import_node_path6;
 var init_adapter = __esm({
   "src/loaders/adapter.ts"() {
     "use strict";
     import_node_url2 = require("url");
-    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_promises4 = __toESM(require("fs/promises"), 1);
     import_node_querystring = require("querystring");
     init_validation();
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
   }
 });
 
 // src/utils/glob-import.ts
 function generateGlobImport(patterns, options) {
   let code = "{";
-  const result = (0, import_tinyglobby2.globSync)(patterns, {
+  const result = (0, import_tinyglobby.globSync)(patterns, {
     cwd: options.base
   });
   for (const item of result) {
-    const fullPath = import_node_path9.default.join(options.base, item);
+    const fullPath = import_node_path7.default.join(options.base, item);
     const url = (0, import_node_url3.pathToFileURL)(fullPath);
     for (const [k, v] of Object.entries(options.query ?? {})) {
       url.searchParams.set(k, v);
@@ -1436,38 +1450,84 @@ function generateGlobImport(patterns, options) {
   code += "}";
   return code;
 }
-var import_tinyglobby2, import_node_path9, import_node_url3;
+var import_tinyglobby, import_node_path7, import_node_url3;
 var init_glob_import = __esm({
   "src/utils/glob-import.ts"() {
     "use strict";
-    import_tinyglobby2 = require("tinyglobby");
-    import_node_path9 = __toESM(require("path"), 1);
+    import_tinyglobby = require("tinyglobby");
+    import_node_path7 = __toESM(require("path"), 1);
     import_node_url3 = require("url");
   }
 });
 
 // src/plugins/vite.ts
-function vite(options) {
+function vite({
+  index
+}) {
   let config;
+  let indexOptions;
+  if (index === false) indexOptions = false;
+  else indexOptions = applyDefaults2(index === true ? {} : index);
   return {
+    name: "vite",
     config(v) {
       config = v;
     },
-    emit() {
-      return [
-        {
-          path: "index.ts",
-          content: indexFile2(this.configPath, this.outDir, config, options)
+    configureServer(server) {
+      if (!server.watcher || indexOptions === false || indexOptions.runtime === false)
+        return;
+      server.watcher.on("all", (event, file) => {
+        if (event === "change") return;
+        const isUpdated = config.collectionList.some((collection) => {
+          if (collection.type === "docs")
+            return collection.docs.hasFile(file) || collection.meta.hasFile(file);
+          return collection.hasFile(file);
+        });
+        if (isUpdated) {
+          this.core.emitAndWrite({
+            filterPlugin: (plugin) => plugin.name === "vite"
+          });
         }
-      ];
+      });
+    },
+    emit() {
+      const out = [];
+      if (indexOptions === false) return out;
+      if (indexOptions.browser) {
+        out.push({
+          path: "browser.ts",
+          content: indexFile2(this, config, indexOptions, "browser")
+        });
+      }
+      out.push({
+        path: "index.ts",
+        content: indexFile2(
+          this,
+          config,
+          indexOptions,
+          indexOptions.browser ? "server" : "all"
+        )
+      });
+      return out;
     }
   };
 }
-function indexFile2(configPath, outDir, config, options) {
-  const { addJsExtension = false, runtime } = options;
+function applyDefaults2(options) {
+  return {
+    addJsExtension: options.addJsExtension ?? false,
+    browser: options.browser ?? false,
+    runtime: options.runtime ?? false
+  };
+}
+function indexFile2({ configPath, outDir }, config, { addJsExtension, runtime }, environment) {
+  const runtimePath = {
+    all: "fumadocs-mdx/runtime/vite",
+    server: "fumadocs-mdx/runtime/vite.server",
+    browser: "fumadocs-mdx/runtime/vite.browser"
+  }[environment];
   const lines = [
     '/// <reference types="vite/client" />',
-    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
+    `import { fromConfig } from '${runtimePath}';`,
     `import type * as Config from '${toImportPath(configPath, {
       relativeTo: outDir,
       jsExtension: addJsExtension
@@ -1475,74 +1535,68 @@ function indexFile2(configPath, outDir, config, options) {
     "",
     `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 `{
+  function generateCollectionGlob(collection) {
+    if (collection.type === "docs") {
+      const obj = [
+        ident(`doc: ${generateCollectionGlob(collection.docs)}`),
+        ident(`meta: ${generateCollectionGlob(collection.meta)}`)
+      ].join(",\n");
+      return `{
 ${obj}
 }`;
-  }
-  function doc(name, collection) {
-    const patterns = getGlobPatterns(collection);
+    }
     const dir = getCollectionDir(collection);
-    const docGlob = generateGlob(patterns, {
-      query: {
-        collection: name
-      },
-      base: dir
-    });
-    if (collection.async) {
-      const headBlob = generateGlob(patterns, {
+    if (collection.type === "doc") {
+      const docGlob = generateGlob(collection.patterns, {
         query: {
-          only: "frontmatter",
-          collection: name
+          collection: collection.name
         },
-        import: "frontmatter",
         base: dir
       });
-      return `create.docLazy("${name}", "${dir}", ${headBlob}, ${docGlob})`;
+      if (collection.async) {
+        const headBlob = generateGlob(collection.patterns, {
+          query: {
+            only: "frontmatter",
+            collection: collection.name
+          },
+          import: "frontmatter",
+          base: dir
+        });
+        return `create.docLazy("${collection.name}", "${dir}", ${headBlob}, ${docGlob})`;
+      }
+      return `create.doc("${collection.name}", "${dir}", ${docGlob})`;
     }
-    return `create.doc("${name}", "${dir}", ${docGlob})`;
-  }
-  function meta(name, collection) {
-    const patterns = getGlobPatterns(collection);
-    const dir = getCollectionDir(collection);
-    return `create.meta("${name}", "${dir}", ${generateGlob(patterns, {
-      import: "default",
-      base: dir,
-      query: {
-        collection: name
+    return `create.meta("${collection.name}", "${dir}", ${generateGlob(
+      collection.patterns,
+      {
+        import: "default",
+        base: dir,
+        query: {
+          collection: collection.name
+        }
       }
-    })})`;
+    )})`;
   }
-  function generateGlob(patterns, options2) {
+  function generateGlob(patterns, options) {
     patterns = patterns.map(normalizeGlobPath);
     if (runtime === "node" || runtime === "bun") {
-      return generateGlobImport(patterns, options2);
+      return generateGlobImport(patterns, options);
     } else {
       return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
         {
-          ...options2,
-          base: normalizeGlobPath(import_node_path10.default.relative(outDir, options2.base))
+          ...options,
+          base: normalizeGlobPath(import_node_path8.default.relative(outDir, options.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);
-    }
+  for (const collection of config.collectionList) {
     lines.push("");
-    lines.push(`export const ${name} = ${body};`);
+    lines.push(
+      `export const ${collection.name} = ${generateCollectionGlob(collection)};`
+    );
   }
   return lines.join("\n");
 }
@@ -1552,8 +1606,7 @@ function normalizeGlobPath(file) {
   if (file.startsWith("/")) return `.${file}`;
   return `./${file}`;
 }
-function getCollectionDir(collection) {
-  const dir = collection.dir;
+function getCollectionDir({ dir }) {
   if (Array.isArray(dir)) {
     if (dir.length !== 1)
       throw new Error(
@@ -1563,43 +1616,55 @@ function getCollectionDir(collection) {
   }
   return dir;
 }
-function slash(path16) {
-  const isExtendedLengthPath = path16.startsWith("\\\\?\\");
+function slash(path13) {
+  const isExtendedLengthPath = path13.startsWith("\\\\?\\");
   if (isExtendedLengthPath) {
-    return path16;
+    return path13;
   }
-  return path16.replaceAll("\\", "/");
+  return path13.replaceAll("\\", "/");
 }
-var import_node_path10;
+var import_node_path8;
 var init_vite = __esm({
   "src/plugins/vite.ts"() {
     "use strict";
     init_import_formatter();
-    init_collections();
     init_glob_import();
-    import_node_path10 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
   }
 });
 
-// src/vite/index.ts
-var vite_exports = {};
-__export(vite_exports, {
-  default: () => mdx,
-  postInstall: () => postInstall2
+// src/loaders/config.ts
+function createIntegratedConfigLoader(core) {
+  return {
+    getConfig() {
+      return core.getConfig();
+    }
+  };
+}
+var import_promises5;
+var init_config = __esm({
+  "src/loaders/config.ts"() {
+    "use strict";
+    import_promises5 = __toESM(require("fs/promises"), 1);
+  }
 });
-async function mdx(config, pluginOptions = {}) {
-  const options = applyDefaults2(pluginOptions);
-  const core = await createViteCore(options).init({
-    config: buildConfig(config)
-  });
-  const mdxLoader = toVite(createMdxLoader(core.creatConfigLoader()));
-  async function transformMeta(path16, query, value) {
-    const isJson = path16.endsWith(".json");
-    const parsed = (0, import_node_querystring2.parse)(query);
-    const collection = parsed.collection ? core.getConfig().collections.get(parsed.collection) : void 0;
+
+// src/loaders/meta.ts
+function createMetaLoader(configLoader, resolve5 = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve5;
+  return async ({ filePath, query, source }) => {
+    const isJson = filePath.endsWith(".json");
+    const parsed = querySchema2.parse(query);
+    const collection = parsed.collection ? (await configLoader.getConfig()).getCollection(parsed.collection) : void 0;
     if (!collection) return null;
+    let data;
+    try {
+      data = isJson ? JSON.parse(source) : (0, import_js_yaml3.load)(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
     let schema;
-    switch (collection.type) {
+    switch (collection?.type) {
       case "meta":
         schema = collection.schema;
         break;
@@ -1607,24 +1672,58 @@ async function mdx(config, pluginOptions = {}) {
         schema = collection.meta.schema;
         break;
     }
-    if (!schema) return null;
-    let data;
-    try {
-      data = isJson ? JSON.parse(value) : (0, import_js_yaml3.load)(value);
-    } catch {
-      return null;
+    if (schema) {
+      data = await validate(
+        schema,
+        data,
+        { path: filePath, source },
+        `invalid data in ${filePath}`
+      );
+    }
+    let code;
+    if (isJson) {
+      code = resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`;
+    } else {
+      code = resolveYaml === "yaml" ? (0, import_js_yaml3.dump)(data) : `export default ${JSON.stringify(data)}`;
     }
-    const out = await validate(
-      schema,
-      data,
-      { path: path16, source: value },
-      `invalid data in ${path16}`
-    );
     return {
-      code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
+      code,
       map: null
     };
+  };
+}
+var import_js_yaml3, import_zod2, querySchema2;
+var init_meta = __esm({
+  "src/loaders/meta.ts"() {
+    "use strict";
+    import_js_yaml3 = require("js-yaml");
+    init_validation();
+    import_zod2 = require("zod");
+    querySchema2 = import_zod2.z.object({
+      collection: import_zod2.z.string().optional()
+    }).loose();
   }
+});
+
+// src/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => mdx,
+  postInstall: () => postInstall2
+});
+async function mdx(config, pluginOptions = {}) {
+  const options = applyDefaults3(pluginOptions);
+  const core = await createViteCore(options).init({
+    config: buildConfig(config)
+  });
+  const configLoader = createIntegratedConfigLoader(core);
+  const mdxLoader = toVite(createMdxLoader(configLoader));
+  const metaLoader = toVite(
+    createMetaLoader(configLoader, {
+      // vite has built-in plugin for JSON files
+      json: "json"
+    })
+  );
   return {
     name: "fumadocs-mdx",
     // needed, otherwise other plugins will be executed before our `transform`.
@@ -1650,13 +1749,15 @@ async function mdx(config, pluginOptions = {}) {
       });
     },
     async transform(value, id) {
-      const [file, query = ""] = id.split("?");
-      const ext = path15.extname(file);
       try {
-        if ([".yaml", ".json"].includes(ext))
-          return await transformMeta(file, query, value);
-        if ([".md", ".mdx"].includes(ext))
+        if (metaLoaderGlob.test(id)) {
+          const [file, query = ""] = id.split("?", 2);
+          return await metaLoader.call(this, file, query, value);
+        }
+        if (mdxLoaderGlob.test(id)) {
+          const [file, query = ""] = id.split("?", 2);
           return await mdxLoader.call(this, file, query, value);
+        }
       } catch (e) {
         if (e instanceof ValidationError) {
           throw new Error(e.toStringFormatted());
@@ -1667,8 +1768,8 @@ async function mdx(config, pluginOptions = {}) {
   };
 }
 async function postInstall2(configPath = findConfigFile(), pluginOptions = {}) {
-  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load(), load_exports));
-  const options = applyDefaults2(pluginOptions);
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
+  const options = applyDefaults3(pluginOptions);
   const core = await createViteCore(options).init({
     config: loadConfig2(configPath, options.outDir, true)
   });
@@ -1686,11 +1787,13 @@ function createViteCore({
       outDir
     },
     [
-      generateIndexFile !== false && vite(typeof generateIndexFile === "object" ? generateIndexFile : {})
+      vite({
+        index: generateIndexFile
+      })
     ]
   );
 }
-function applyDefaults2(options) {
+function applyDefaults3(options) {
   return {
     updateViteConfig: options.updateViteConfig ?? true,
     generateIndexFile: options.generateIndexFile ?? true,
@@ -1698,21 +1801,20 @@ function applyDefaults2(options) {
     outDir: options.outDir ?? ".source"
   };
 }
-var import_vite, import_node_querystring2, path15, import_js_yaml3, FumadocsDeps;
+var import_vite, FumadocsDeps;
 var init_vite2 = __esm({
   "src/vite/index.ts"() {
     "use strict";
     import_vite = require("vite");
     init_build();
-    import_node_querystring2 = require("querystring");
     init_validation();
-    path15 = __toESM(require("path"), 1);
-    import_js_yaml3 = require("js-yaml");
     init_mdx();
-    init_config();
     init_adapter();
     init_vite();
     init_core();
+    init_config();
+    init_meta();
+    init_loaders();
     FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
   }
 });