fumadocs-mdx 13.0.0 → 13.0.2

package/dist/next/index.cjs

@@ -195,53 +195,23 @@ 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();
   }
 });
 
-// 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);
-    }
-  }
-  return watcher2;
-}
-var import_chokidar;
-var init_watcher = __esm({
-  "src/next/watcher.ts"() {
-    "use strict";
-    import_chokidar = require("chokidar");
-  }
-});
-
 // src/next/index.ts
 var next_exports = {};
 __export(next_exports, {
@@ -257,61 +227,20 @@ function findConfigFile() {
   return import_node_path.default.resolve("source.config.ts");
 }
 
-// src/plugins/index.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_promises2 = __toESM(require("fs/promises"), 1);
-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));
-    }
-  };
-}
-
 // src/next/index.ts
-var path8 = __toESM(require("path"), 1);
+var path9 = __toESM(require("path"), 1);
 init_load();
 
 // src/next/file-cache.ts
 var import_lru_cache = require("lru-cache");
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var map = new import_lru_cache.LRUCache({
   max: 100
 });
 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;
 }
@@ -319,7 +248,7 @@ 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;
 }
@@ -368,11 +297,10 @@ async function validate(schema, data, context, errorMessage) {
 // src/plugins/next.ts
 var path7 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
-var import_tinyglobby = require("tinyglobby");
 var import_js_yaml2 = require("js-yaml");
 
 // src/utils/git-timestamp.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_tinyexec = require("tinyexec");
 var cache = /* @__PURE__ */ new Map();
 async function getGitTimestamp(file) {
@@ -381,7 +309,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
       }
@@ -411,7 +339,7 @@ function fumaMatter(input) {
 }
 
 // src/utils/import-formatter.ts
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 function getImportCode(info) {
   const specifier = JSON.stringify(info.specifier);
   if (info.type === "default") return `import ${info.name} from ${specifier}`;
@@ -426,7 +354,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";
@@ -437,40 +365,78 @@ 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, "/");
 }
 
 // src/utils/collections.ts
-function getSupportedFormats(collection) {
-  return {
-    doc: ["mdx", "md"],
-    meta: ["json", "yaml"]
-  }[collection.type];
-}
+var import_picomatch = __toESM(require("picomatch"), 1);
+var import_tinyglobby = require("tinyglobby");
+var import_node_path5 = __toESM(require("path"), 1);
+var SupportedFormats = {
+  doc: ["mdx", "md"],
+  meta: ["json", "yaml"]
+};
 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());
 }
 
 // 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 [
@@ -613,27 +579,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 extname2 = path7.extname(file);
   try {
@@ -647,6 +592,79 @@ function parseMetaEntry(file, content) {
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
+// src/core.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+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 start = 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() - start}ms`);
+    }
+  };
+}
+
 // src/next/index.ts
 var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
 function createMDX(createOptions = {}) {
@@ -701,63 +719,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 start = 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() - start}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 {
@@ -765,11 +783,11 @@ function applyDefaults(options) {
     configPath: options.configPath ?? findConfigFile()
   };
 }
-function createNextPluginHandler({
+function createNextCore({
   outDir,
   configPath
 }) {
-  return createPluginHandler(
+  const core = createCore(
     {
       environment: "next",
       outDir,
@@ -777,6 +795,20 @@ 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);
+        }
+      }
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {