fumadocs-mdx 13.0.0 → 13.0.2

package/dist/bin.cjs

@@ -34,13 +34,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 function findConfigFile() {
   return import_node_path.default.resolve("source.config.ts");
 }
-function resolvedConfig(loaded) {
-  return {
-    getConfig() {
-      return loaded;
-    }
-  };
-}
 var import_node_path, import_promises;
 var init_config = __esm({
   "src/loaders/config/index.ts"() {
@@ -50,53 +43,6 @@ var init_config = __esm({
   }
 });
 
-// src/plugins/index.ts
-function createPluginHandler(context, defaultPlugins = []) {
-  const plugins2 = [];
-  async function write(entry) {
-    const file = import_node_path2.default.join(context.outDir, entry.path);
-    await import_promises2.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-    await import_promises2.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));
-    }
-  };
-}
-var import_node_path2, import_promises2;
-var init_plugins = __esm({
-  "src/plugins/index.ts"() {
-    "use strict";
-    import_node_path2 = __toESM(require("path"), 1);
-    import_promises2 = __toESM(require("fs/promises"), 1);
-  }
-});
-
 // src/loaders/mdx/preset.ts
 var preset_exports = {};
 __export(preset_exports, {
@@ -266,18 +212,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)(path3.resolve(outDir, "source.config.mjs"));
+  const url = (0, import_node_url.pathToFileURL)(path2.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 path3, import_node_url;
+var path2, import_node_url;
 var init_load = __esm({
   "src/loaders/config/load.ts"() {
     "use strict";
-    path3 = __toESM(require("path"), 1);
+    path2 = __toESM(require("path"), 1);
     import_node_url = require("url");
     init_build();
   }
@@ -285,8 +231,8 @@ var init_load = __esm({
 
 // src/next/file-cache.ts
 function toFullPath(file) {
-  if (import_node_path3.default.isAbsolute(file)) {
-    return import_node_path3.default.relative(process.cwd(), file);
+  if (import_node_path2.default.isAbsolute(file)) {
+    return import_node_path2.default.relative(process.cwd(), file);
   }
   return file;
 }
@@ -294,20 +240,20 @@ async function readFileWithCache(file) {
   const fullPath = toFullPath(file);
   const cached = map.get(fullPath);
   if (cached) return cached;
-  const read = import_promises3.default.readFile(fullPath).then((s) => s.toString());
+  const read = import_promises2.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_promises3, import_node_path3, map;
+var import_lru_cache, import_promises2, import_node_path2, map;
 var init_file_cache = __esm({
   "src/next/file-cache.ts"() {
     "use strict";
     import_lru_cache = require("lru-cache");
-    import_promises3 = __toESM(require("fs/promises"), 1);
-    import_node_path3 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
     map = new import_lru_cache.LRUCache({
       max: 100
     });
@@ -365,7 +311,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path4.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path3.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -377,11 +323,11 @@ async function getGitTimestamp(file) {
     return;
   }
 }
-var import_node_path4, import_tinyexec, cache;
+var import_node_path3, import_tinyexec, cache;
 var init_git_timestamp = __esm({
   "src/utils/git-timestamp.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
     import_tinyexec = require("tinyexec");
     cache = /* @__PURE__ */ new Map();
   }
@@ -424,7 +370,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path5.default.extname(file);
+  const ext = import_node_path4.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -435,55 +381,94 @@ function toImportPath(file, config) {
   }
   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 = import_node_path4.default.relative(config.relativeTo, filename);
+    if (!import_node_path4.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path5.default.resolve(filename);
+    importPath = import_node_path4.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path5.default.sep, "/");
+  return importPath.replaceAll(import_node_path4.default.sep, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_node_path5;
+var import_node_path4;
 var init_import_formatter = __esm({
   "src/utils/import-formatter.ts"() {
     "use strict";
-    import_node_path5 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
   }
 });
 
 // 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(",")}}`];
+  return [`**/*.{${SupportedFormats[collection.type].join(",")}}`];
 }
 function isFileSupported(filePath, collection) {
-  for (const format of getSupportedFormats(collection)) {
-    if (filePath.endsWith(`.${format}`)) return true;
-  }
-  return false;
+  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"]
+    };
   }
 });
 
 // src/plugins/next.ts
 function next() {
   let config;
+  let shouldEmitOnChange = false;
   return {
+    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;
+        }
+      }
+    },
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async () => {
+        if (!shouldEmitOnChange) return;
+        await this.core.emitAndWrite({
+          filterPlugin: (plugin) => plugin.name === "next"
+        });
+      });
     },
     async emit() {
       return [
@@ -626,27 +611,6 @@ async function indexFile(configPath, config, importPath, configHash = false) {
     ...resolvedDeclares
   ].join("\n");
 }
-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: path7.resolve(dir)
-      });
-      for (const item of result) {
-        if (!isFileSupported(item, collection)) continue;
-        const fullPath = path7.join(dir, item);
-        files.set(fullPath, {
-          path: item,
-          fullPath
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
-}
 function parseMetaEntry(file, content) {
   const extname4 = path7.extname(file);
   try {
@@ -659,13 +623,12 @@ function parseMetaEntry(file, content) {
   }
   throw new Error(`Unknown meta file format: ${extname4}, in ${file}.`);
 }
-var path7, import_node_crypto, import_tinyglobby, import_js_yaml2;
+var path7, import_node_crypto, import_js_yaml2;
 var init_next = __esm({
   "src/plugins/next.ts"() {
     "use strict";
     path7 = __toESM(require("path"), 1);
     import_node_crypto = require("crypto");
-    import_tinyglobby = require("tinyglobby");
     init_validation();
     init_file_cache();
     import_js_yaml2 = require("js-yaml");
@@ -676,33 +639,82 @@ var init_next = __esm({
   }
 });
 
-// src/next/watcher.ts
-var watcher_exports = {};
-__export(watcher_exports, {
-  watcher: () => watcher
-});
-function watcher(configPath, config, ignored) {
-  const watcher2 = new import_chokidar.FSWatcher({
-    ignoreInitial: true,
-    persistent: true,
-    ignored
-  });
-  watcher2.add(configPath);
-  for (const collection of config.collections.values()) {
-    if (collection.type === "docs") {
-      watcher2.add(collection.docs.dir);
-      watcher2.add(collection.meta.dir);
-    } else {
-      watcher2.add(collection.dir);
+// src/core.ts
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins2;
+  return {
+    _options: options,
+    getPluginContext() {
+      return {
+        core: this,
+        ...options
+      };
+    },
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: /* @__PURE__ */ new Map(),
+    async init({ config: newConfig }) {
+      config = await newConfig;
+      this.cache.clear();
+      plugins2 = [];
+      for await (const option of [
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]) {
+        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(this.getPluginContext(), config);
+        if (out) config = out;
+      }
+      return this;
+    },
+    getConfig() {
+      return config;
+    },
+    creatConfigLoader() {
+      return {
+        getConfig() {
+          return config;
+        }
+      };
+    },
+    async initServer(server) {
+      for (const plugin of plugins2) {
+        await plugin.configureServer?.call(this.getPluginContext(), server);
+      }
+    },
+    async emitAndWrite({
+      filterPlugin = () => true
+    } = {}) {
+      const start2 = performance.now();
+      const out = await Promise.all(
+        plugins2.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(this.getPluginContext());
+        })
+      );
+      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);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start2}ms`);
     }
-  }
-  return watcher2;
+  };
 }
-var import_chokidar;
-var init_watcher = __esm({
-  "src/next/watcher.ts"() {
+var import_node_path6, import_promises3;
+var init_core = __esm({
+  "src/core.ts"() {
     "use strict";
-    import_chokidar = require("chokidar");
+    import_node_path6 = __toESM(require("path"), 1);
+    import_promises3 = __toESM(require("fs/promises"), 1);
   }
 });
 
@@ -764,63 +776,63 @@ function createMDX(createOptions = {}) {
   };
 }
 async function init(dev, options) {
-  const pluginHandler = createNextPluginHandler(options);
-  let config;
-  async function updateConfig() {
-    config = await pluginHandler.init(
-      await loadConfig(options.configPath, options.outDir, true)
-    );
+  const core = createNextCore(options);
+  async function initOrReload() {
+    await core.init({
+      config: loadConfig(options.configPath, options.outDir, true)
+    });
+    await core.emitAndWrite();
   }
-  async function emitFiles() {
-    const start2 = performance.now();
-    try {
-      await pluginHandler.emitAndWrite();
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        console.error(err.toStringFormatted());
+  async function devServer() {
+    const { FSWatcher } = await import("chokidar");
+    const watcher = new FSWatcher({
+      ignoreInitial: true,
+      persistent: true,
+      ignored: [options.outDir]
+    });
+    watcher.add(options.configPath);
+    for (const collection of core.getConfig().collections.values()) {
+      if (collection.type === "docs") {
+        watcher.add(collection.docs.dir);
+        watcher.add(collection.meta.dir);
       } else {
-        console.error(err);
+        watcher.add(collection.dir);
       }
     }
-    console.log(`[MDX] updated map file in ${performance.now() - start2}ms`);
-  }
-  async function devServer() {
-    const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
-    const instance = watcher2(options.configPath, config, [options.outDir]);
-    async function onUpdate(event, file) {
-      const absolutePath = path8.resolve(file);
+    watcher.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    watcher.on("all", async (event, file) => {
+      const absolutePath = path9.resolve(file);
       if (event === "change") removeFileCache(absolutePath);
-      if (absolutePath === path8.resolve(options.configPath)) {
-        await updateConfig();
+      if (absolutePath === path9.resolve(options.configPath)) {
+        watcher.removeAllListeners();
+        await watcher.close();
+        await initOrReload();
         console.log("[MDX] restarting dev server");
-        await instance.close();
-        void devServer();
+        await devServer();
       }
-      await emitFiles();
-    }
-    instance.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    instance.on("all", (event, file) => {
-      void onUpdate(event, file);
     });
     process.on("exit", () => {
+      if (watcher.closed) return;
       console.log("[MDX] closing dev server");
-      void instance.close();
+      void watcher.close();
     });
+    await core.initServer({ watcher });
+  }
+  await initOrReload();
+  if (dev) {
+    await devServer();
   }
-  await updateConfig();
-  await emitFiles();
-  if (dev) void devServer();
 }
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
-  const pluginHandler = createNextPluginHandler({
+  const core = await createNextCore({
     outDir,
     configPath
+  }).init({
+    config: loadConfig(configPath, outDir, true)
   });
-  await pluginHandler.init(await loadConfig(configPath, outDir, true));
-  await pluginHandler.emitAndWrite();
-  console.log("[MDX] types generated");
+  await core.emitAndWrite();
 }
 function applyDefaults(options) {
   return {
@@ -828,11 +840,11 @@ function applyDefaults(options) {
     configPath: options.configPath ?? findConfigFile()
   };
 }
-function createNextPluginHandler({
+function createNextCore({
   outDir,
   configPath
 }) {
-  return createPluginHandler(
+  const core = createCore(
     {
       environment: "next",
       outDir,
@@ -840,18 +852,32 @@ function createNextPluginHandler({
     },
     [next()]
   );
+  return {
+    ...core,
+    async emitAndWrite(...args) {
+      try {
+        await core.emitAndWrite(...args);
+      } catch (err) {
+        if (err instanceof ValidationError) {
+          console.error(err.toStringFormatted());
+        } else {
+          console.error(err);
+        }
+      }
+    }
+  };
 }
-var path8, defaultPageExtensions;
+var path9, defaultPageExtensions;
 var init_next2 = __esm({
   "src/next/index.ts"() {
     "use strict";
     init_config();
-    init_plugins();
-    path8 = __toESM(require("path"), 1);
+    path9 = __toESM(require("path"), 1);
     init_load();
     init_file_cache();
     init_validation();
     init_next();
+    init_core();
     defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
   }
 });
@@ -982,7 +1008,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path9.extname(file);
+    const ext = path10.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -1015,7 +1041,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path9.dirname(file), data);
+    await update(mdast, path10.dirname(file), data);
     return mdast;
   };
   async function update(tree, directory, data) {
@@ -1027,7 +1053,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 = path9.resolve(
+      const file = path10.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -1044,16 +1070,16 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path9.dirname(file.path), file.data);
+    await update(tree, path10.dirname(file.path), file.data);
   };
 }
-var import_unified, import_unist_util_visit2, path9, fs4, import_mdx_plugins, ElementLikeTypes;
+var import_unified, import_unist_util_visit2, path10, fs4, 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");
-    path9 = __toESM(require("path"), 1);
+    path10 = __toESM(require("path"), 1);
     fs4 = __toESM(require("fs/promises"), 1);
     init_fuma_matter();
     import_mdx_plugins = require("fumadocs-core/mdx-plugins");
@@ -1234,13 +1260,6 @@ var init_build_mdx = __esm({
 });
 
 // src/loaders/mdx/index.ts
-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,
@@ -1251,14 +1270,25 @@ function createMdxLoader(configLoader) {
   }) => {
     const matter = fumaMatter(value);
     const parsed = querySchema.parse(query);
-    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_promises4.default.readFile(import_node_path6.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+    const config = await configLoader.getConfig();
+    let after;
+    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);
       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),
+          JSON.stringify({
+            ...out,
+            hash: generateCacheHash(value)
+          })
+        );
+      };
     }
-    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -1286,16 +1316,16 @@ function createMdxLoader(configLoader) {
       };
     }
     const data = {};
-    if (loaded.global.lastModifiedTime === "git") {
+    if (config.global.lastModifiedTime === "git") {
       data.lastModified = (await getGitTimestamp(filePath))?.getTime();
     }
     const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
     const compiled = await buildMDX(
-      `${getConfigHash(loaded)}:${parsed.collection ?? "global"}`,
+      `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
-        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
         postprocess: docCollection?.postprocess,
         data,
         filePath,
@@ -1307,19 +1337,17 @@ function createMdxLoader(configLoader) {
       code: String(compiled.value),
       map: compiled.map
     };
-    if (cacheDir) {
-      await import_promises4.default.mkdir(cacheDir, { recursive: true });
-      await import_promises4.default.writeFile(
-        import_node_path6.default.join(cacheDir, cacheKey),
-        JSON.stringify({
-          ...out,
-          hash: generateCacheHash(value)
-        })
-      );
-    }
+    await after?.();
     return out;
   };
 }
+function getConfigHash(config) {
+  let hash = hashes.get(config);
+  if (hash) return hash;
+  hash = Date.now().toString();
+  hashes.set(config, hash);
+  return hash;
+}
 function generateCacheHash(input) {
   return (0, import_node_crypto2.createHash)("md5").update(input).digest("hex");
 }
@@ -1330,7 +1358,7 @@ function countLines(s) {
   }
   return num;
 }
-var import_zod, import_promises4, import_node_path6, import_node_crypto2, querySchema, cacheEntry, hashes;
+var import_zod, import_promises4, import_node_path7, import_node_crypto2, querySchema, cacheEntry, hashes;
 var init_mdx = __esm({
   "src/loaders/mdx/index.ts"() {
     "use strict";
@@ -1340,7 +1368,7 @@ var init_mdx = __esm({
     init_build_mdx();
     import_zod = require("zod");
     import_promises4 = __toESM(require("fs/promises"), 1);
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     querySchema = import_zod.z.object({
       only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
@@ -1375,7 +1403,7 @@ function toVite(loader) {
     };
   };
 }
-var import_node_url2, import_promises5, import_node_querystring, import_node_path7;
+var import_node_url2, import_promises5, import_node_querystring, import_node_path8;
 var init_adapter = __esm({
   "src/loaders/adapter.ts"() {
     "use strict";
@@ -1383,7 +1411,7 @@ var init_adapter = __esm({
     import_promises5 = __toESM(require("fs/promises"), 1);
     import_node_querystring = require("querystring");
     init_validation();
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
   }
 });
 
@@ -1394,7 +1422,7 @@ function generateGlobImport(patterns, options) {
     cwd: options.base
   });
   for (const item of result) {
-    const fullPath = import_node_path8.default.join(options.base, item);
+    const fullPath = import_node_path9.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);
@@ -1408,12 +1436,12 @@ function generateGlobImport(patterns, options) {
   code += "}";
   return code;
 }
-var import_tinyglobby2, import_node_path8, import_node_url3;
+var import_tinyglobby2, import_node_path9, import_node_url3;
 var init_glob_import = __esm({
   "src/utils/glob-import.ts"() {
     "use strict";
     import_tinyglobby2 = require("tinyglobby");
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
     import_node_url3 = require("url");
   }
 });
@@ -1426,7 +1454,6 @@ function vite(options) {
       config = v;
     },
     emit() {
-      console.log("[Fumadocs MDX] Generating index files");
       return [
         {
           path: "index.ts",
@@ -1459,12 +1486,12 @@ ${obj}
   }
   function doc(name, collection) {
     const patterns = getGlobPatterns(collection);
-    const base = getGlobBase(collection);
+    const dir = getCollectionDir(collection);
     const docGlob = generateGlob(patterns, {
       query: {
         collection: name
       },
-      base
+      base: dir
     });
     if (collection.async) {
       const headBlob = generateGlob(patterns, {
@@ -1473,32 +1500,32 @@ ${obj}
           collection: name
         },
         import: "frontmatter",
-        base
+        base: dir
       });
-      return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
+      return `create.docLazy("${name}", "${dir}", ${headBlob}, ${docGlob})`;
     }
-    return `create.doc("${name}", "${base}", ${docGlob})`;
+    return `create.doc("${name}", "${dir}", ${docGlob})`;
   }
   function meta(name, collection) {
     const patterns = getGlobPatterns(collection);
-    const base = getGlobBase(collection);
-    return `create.meta("${name}", "${base}", ${generateGlob(patterns, {
+    const dir = getCollectionDir(collection);
+    return `create.meta("${name}", "${dir}", ${generateGlob(patterns, {
       import: "default",
-      base,
+      base: dir,
       query: {
         collection: name
       }
     })})`;
   }
   function generateGlob(patterns, options2) {
-    patterns = mapGlobPatterns(patterns);
+    patterns = patterns.map(normalizeGlobPath);
     if (runtime === "node" || runtime === "bun") {
       return generateGlobImport(patterns, options2);
     } else {
       return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
         {
           ...options2,
-          base: import_node_path9.default.relative(outDir, options2.base)
+          base: normalizeGlobPath(import_node_path10.default.relative(outDir, options2.base))
         },
         null,
         2
@@ -1519,33 +1546,38 @@ ${obj}
   }
   return lines.join("\n");
 }
-function mapGlobPatterns(patterns) {
-  return patterns.map(enforceRelative);
-}
-function enforceRelative(file) {
+function normalizeGlobPath(file) {
+  file = slash(file);
   if (file.startsWith("./")) return file;
   if (file.startsWith("/")) return `.${file}`;
   return `./${file}`;
 }
-function getGlobBase(collection) {
-  let dir = collection.dir;
+function getCollectionDir(collection) {
+  const 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 dir[0];
+  }
+  return dir;
+}
+function slash(path16) {
+  const isExtendedLengthPath = path16.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path16;
   }
-  return enforceRelative(dir);
+  return path16.replaceAll("\\", "/");
 }
-var import_node_path9;
+var import_node_path10;
 var init_vite = __esm({
   "src/plugins/vite.ts"() {
     "use strict";
     init_import_formatter();
     init_collections();
     init_glob_import();
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
   }
 });
 
@@ -1557,14 +1589,14 @@ __export(vite_exports, {
 });
 async function mdx(config, pluginOptions = {}) {
   const options = applyDefaults2(pluginOptions);
-  const { updateViteConfig } = options;
-  const pluginHandler = createVitePluginHandler(options);
-  const loaded = await pluginHandler.init(buildConfig(config));
-  const mdxLoader = toVite(createMdxLoader(resolvedConfig(loaded)));
-  async function transformMeta(path15, query, value) {
-    const isJson = path15.endsWith(".json");
+  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 ? loaded.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? core.getConfig().collections.get(parsed.collection) : void 0;
     if (!collection) return null;
     let schema;
     switch (collection.type) {
@@ -1585,8 +1617,8 @@ async function mdx(config, pluginOptions = {}) {
     const out = await validate(
       schema,
       data,
-      { path: path15, source: value },
-      `invalid data in ${path15}`
+      { path: path16, source: value },
+      `invalid data in ${path16}`
     );
     return {
       code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
@@ -1598,7 +1630,7 @@ async function mdx(config, pluginOptions = {}) {
     // needed, otherwise other plugins will be executed before our `transform`.
     enforce: "pre",
     config(config2) {
-      if (!updateViteConfig) return config2;
+      if (!options.updateViteConfig) return config2;
       return (0, import_vite.mergeConfig)(config2, {
         optimizeDeps: {
           exclude: FumadocsDeps
@@ -1610,11 +1642,16 @@ async function mdx(config, pluginOptions = {}) {
       });
     },
     async buildStart() {
-      await pluginHandler.emitAndWrite();
+      await core.emitAndWrite();
+    },
+    async configureServer(server) {
+      await core.initServer({
+        watcher: server.watcher
+      });
     },
     async transform(value, id) {
       const [file, query = ""] = id.split("?");
-      const ext = path14.extname(file);
+      const ext = path15.extname(file);
       try {
         if ([".yaml", ".json"].includes(ext))
           return await transformMeta(file, query, value);
@@ -1632,17 +1669,17 @@ 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 pluginHandler = createVitePluginHandler(options);
-  await pluginHandler.init(await loadConfig2(configPath, options.outDir, true));
-  await pluginHandler.emitAndWrite();
-  console.log("[MDX] types generated");
+  const core = await createViteCore(options).init({
+    config: loadConfig2(configPath, options.outDir, true)
+  });
+  await core.emitAndWrite();
 }
-function createVitePluginHandler({
+function createViteCore({
   configPath,
   outDir,
   generateIndexFile
 }) {
-  return createPluginHandler(
+  return createCore(
     {
       environment: "vite",
       configPath,
@@ -1661,7 +1698,7 @@ function applyDefaults2(options) {
     outDir: options.outDir ?? ".source"
   };
 }
-var import_vite, import_node_querystring2, path14, import_js_yaml3, FumadocsDeps;
+var import_vite, import_node_querystring2, path15, import_js_yaml3, FumadocsDeps;
 var init_vite2 = __esm({
   "src/vite/index.ts"() {
     "use strict";
@@ -1669,13 +1706,13 @@ var init_vite2 = __esm({
     init_build();
     import_node_querystring2 = require("querystring");
     init_validation();
-    path14 = __toESM(require("path"), 1);
+    path15 = __toESM(require("path"), 1);
     import_js_yaml3 = require("js-yaml");
     init_mdx();
     init_config();
     init_adapter();
     init_vite();
-    init_plugins();
+    init_core();
     FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
   }
 });