fumadocs-mdx 11.6.0 → 13.0.1

package/dist/next/index.cjs

@@ -30,59 +30,97 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/map/watcher.ts
-var watcher_exports = {};
-__export(watcher_exports, {
-  watcher: () => watcher
+// src/loaders/mdx/preset.ts
+var preset_exports = {};
+__export(preset_exports, {
+  getDefaultMDXOptions: () => getDefaultMDXOptions
 });
-function watcher(configPath, config) {
-  const deps = [configPath];
-  function add(dir) {
-    if (Array.isArray(dir)) deps.push(...dir);
-    else deps.push(dir);
-  }
-  for (const collection of config.collections.values()) {
-    if (collection.type === "docs") {
-      add(collection.docs.dir);
-      add(collection.meta.dir);
-    } else {
-      add(collection.dir);
-    }
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
   }
-  return (0, import_chokidar.watch)(deps, {
-    ignoreInitial: true,
-    persistent: true
-  });
+  return list;
 }
-var import_chokidar;
-var init_watcher = __esm({
-  "src/map/watcher.ts"() {
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  remarkCodeTabOptions,
+  remarkNpmOptions,
+  _withoutBundler = false,
+  ...mdxOptions
+}) {
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [
+        plugins.remarkImage,
+        {
+          ...remarkImageOptions,
+          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
+        }
+      ],
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+        plugins.remarkCodeTab,
+        remarkCodeTabOptions
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      () => {
+        return (_, file) => {
+          file.data["mdx-export"] ??= [];
+          for (const name of valueToExport) {
+            if (name in file.data)
+              file.data["mdx-export"].push({ name, value: file.data[name] });
+          }
+        };
+      }
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      plugins.rehypeToc
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    outputFormat: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+var plugins;
+var init_preset = __esm({
+  "src/loaders/mdx/preset.ts"() {
     "use strict";
-    import_chokidar = require("chokidar");
+    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
   }
 });
 
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall,
-  start: () => start
-});
-module.exports = __toCommonJS(next_exports);
-
-// src/next/create.ts
-var import_node_path2 = __toESM(require("path"), 1);
-
-// src/utils/config.ts
-var fs = __toESM(require("fs/promises"), 1);
-var path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-
 // src/config/build.ts
 function buildConfig(config) {
   const collections = /* @__PURE__ */ new Map();
-  let globalConfig;
+  let globalConfig = {};
   for (const [k, v] of Object.entries(config)) {
     if (!v) {
       continue;
@@ -97,36 +135,51 @@ function buildConfig(config) {
         continue;
       }
     }
-    if (k === "default") {
+    if (k === "default" && v) {
       globalConfig = v;
       continue;
     }
-    return [
-      `Unknown export "${k}", you can only export collections from source configuration file.`,
-      null
-    ];
+    throw new Error(
+      `Unknown export "${k}", you can only export collections from source configuration file.`
+    );
   }
-  return [
-    null,
-    {
-      global: globalConfig,
-      collections
+  const mdxOptionsCache = /* @__PURE__ */ new Map();
+  return {
+    global: globalConfig,
+    collections,
+    async getDefaultMDXOptions(mode = "default") {
+      const cached = mdxOptionsCache.get(mode);
+      if (cached) return cached;
+      const input = this.global.mdxOptions;
+      async function uncached() {
+        const options = typeof input === "function" ? await input() : input;
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
+        if (options?.preset === "minimal") return options;
+        return getDefaultMDXOptions2({
+          ...options,
+          _withoutBundler: mode === "remote"
+        });
+      }
+      const result = uncached();
+      mdxOptionsCache.set(mode, result);
+      return result;
     }
-  ];
+  };
 }
+var init_build = __esm({
+  "src/config/build.ts"() {
+    "use strict";
+  }
+});
 
-// src/utils/config.ts
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
-var cache = null;
-async function compileConfig(configPath, outDir2) {
+// src/loaders/config/load.ts
+async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
     entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
-    outdir: outDir2,
-    target: "node18",
+    outdir: outDir,
+    target: "node20",
     write: true,
     platform: "node",
     format: "esm",
@@ -140,89 +193,89 @@ async function compileConfig(configPath, outDir2) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, hash, build = false) {
-  if (cache && cache.hash === hash) {
-    return await cache.config;
-  }
-  if (build) await compileConfig(configPath, ".source");
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
-  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
-    const [err, config2] = buildConfig(
-      // every call to `loadConfig` will cause the previous cache to be ignored
-      loaded
-    );
-    if (err !== null) throw new Error(err);
-    return config2;
-  });
-  cache = { config, hash };
+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"));
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
   return await config;
 }
-async function getConfigHash(configPath) {
-  const stats = await fs.stat(configPath).catch(() => void 0);
-  if (stats) {
-    return stats.mtime.getTime().toString();
+var path2, import_node_url;
+var init_load = __esm({
+  "src/loaders/config/load.ts"() {
+    "use strict";
+    path2 = __toESM(require("path"), 1);
+    import_node_url = require("url");
+    init_build();
   }
-  throw new Error("Cannot find config file");
-}
+});
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall
+});
+module.exports = __toCommonJS(next_exports);
 
-// src/map/index.ts
-var path3 = __toESM(require("path"), 1);
-var fs3 = __toESM(require("fs/promises"), 1);
+// src/loaders/config/index.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+function findConfigFile() {
+  return import_node_path.default.resolve("source.config.ts");
+}
 
-// src/map/generate.ts
-var path2 = __toESM(require("path"), 1);
-var fs2 = __toESM(require("fs/promises"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
+// src/next/index.ts
+var path9 = __toESM(require("path"), 1);
+init_load();
 
-// src/utils/get-type-from-path.ts
-var import_node_path = require("path");
-var docTypes = [".mdx", ".md"];
-var metaTypes = [".json", ".yaml"];
-function getTypeFromPath(path6) {
-  const ext = (0, import_node_path.extname)(path6);
-  if (docTypes.includes(ext)) return "doc";
-  if (metaTypes.includes(ext)) return "meta";
+// src/next/file-cache.ts
+var import_lru_cache = require("lru-cache");
+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_path2.default.isAbsolute(file)) {
+    return import_node_path2.default.relative(process.cwd(), file);
+  }
+  return file;
+}
+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());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
 }
 
-// src/utils/schema.ts
-var import_zod = require("zod");
+// src/utils/validation.ts
 var import_picocolors = __toESM(require("picocolors"), 1);
-var metaSchema = import_zod.z.object({
-  title: import_zod.z.string().optional(),
-  pages: import_zod.z.array(import_zod.z.string()).optional(),
-  description: import_zod.z.string().optional(),
-  root: import_zod.z.boolean().optional(),
-  defaultOpen: import_zod.z.boolean().optional(),
-  icon: import_zod.z.string().optional()
-});
-var frontmatterSchema = import_zod.z.object({
-  title: import_zod.z.string(),
-  description: import_zod.z.string().optional(),
-  icon: import_zod.z.string().optional(),
-  full: import_zod.z.boolean().optional(),
-  // Fumadocs OpenAPI generated
-  _openapi: import_zod.z.object({}).passthrough().optional()
-});
 var ValidationError = class extends Error {
   constructor(message, issues) {
-    super(message);
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+    this.title = message;
     this.issues = issues;
   }
-  print() {
-    console.error(
-      [
-        `[MDX] ${this.message}:`,
-        ...this.issues.map(
-          (issue) => import_picocolors.default.redBright(
-            `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-          )
+  toStringFormatted() {
+    return [
+      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => import_picocolors.default.redBright(
+          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
         )
-      ].join("\n")
-    );
-  }
-  toString() {
-    return `${this.message}:
-${this.issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
+      )
+    ].join("\n");
   }
 };
 async function validate(schema, data, context, errorMessage) {
@@ -241,45 +294,173 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
-// src/map/file-cache.ts
-var import_lru_cache = require("lru-cache");
-var map = new import_lru_cache.LRUCache({
-  max: 200
-});
-var fileCache = {
-  read(namespace, path6) {
-    return map.get(`${namespace}.${path6}`);
-  },
-  write(namespace, path6, data) {
-    map.set(`${namespace}.${path6}`, data);
-  },
-  removeCache(path6) {
-    for (const key of map.keys()) {
-      const keyPath = key.slice(key.indexOf(".") + 1);
-      if (keyPath === path6) map.delete(key);
+// src/plugins/next.ts
+var path7 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var import_js_yaml2 = require("js-yaml");
+
+// src/utils/git-timestamp.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_tinyexec = require("tinyexec");
+var cache = /* @__PURE__ */ new Map();
+async function getGitTimestamp(file) {
+  const cached = cache.get(file);
+  if (cached) return cached;
+  try {
+    const out = await (0, import_tinyexec.x)(
+      "git",
+      ["log", "-1", '--pretty="%ai"', import_node_path3.default.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
+    );
+    const time = new Date(out.stdout);
+    cache.set(file, time);
+    return time;
+  } catch {
+    return;
+  }
+}
+
+// src/utils/fuma-matter.ts
+var import_js_yaml = require("js-yaml");
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = (0, import_js_yaml.load)(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+// src/utils/import-formatter.ts
+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}`;
+  if (info.type === "namespace")
+    return `import * as ${info.name} from ${specifier}`;
+  if (info.type === "named") {
+    const names = info.names.map(
+      (name) => Array.isArray(name) ? `${name[0]} as ${name[1]}` : name
+    );
+    return `import { ${names.join(", ")} } from ${specifier}`;
+  }
+  return `import ${specifier}`;
+}
+function toImportPath(file, config) {
+  const ext = import_node_path4.default.extname(file);
+  let filename;
+  if (ext === ".ts" && config.jsExtension) {
+    filename = file.substring(0, file.length - ext.length) + ".js";
+  } else if (ext === ".ts") {
+    filename = file.substring(0, file.length - ext.length);
+  } else {
+    filename = file;
+  }
+  let importPath;
+  if ("relativeTo" in config) {
+    importPath = import_node_path4.default.relative(config.relativeTo, filename);
+    if (!import_node_path4.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+      importPath = `./${importPath}`;
     }
+  } else {
+    importPath = import_node_path4.default.resolve(filename);
   }
+  return importPath.replaceAll(import_node_path4.default.sep, "/");
+}
+
+// src/utils/collections.ts
+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 [`**/*.{${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());
+}
 
-// src/map/generate.ts
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-async function readFileWithCache(file) {
-  const cached = fileCache.read("read-file", file);
-  if (cached) return cached;
-  return (await fs2.readFile(file)).toString();
+// 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 [
+        {
+          path: "index.ts",
+          content: await indexFile(this.configPath, config, {
+            relativeTo: this.outDir
+          })
+        }
+      ];
+    }
+  };
 }
-async function generateJS(configPath, config, outputPath, configHash) {
-  const outDir2 = path2.dirname(outputPath);
+async function indexFile(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
     getImportCode({
       type: "named",
       names: ["_runtime"],
-      specifier: "fumadocs-mdx"
+      specifier: "fumadocs-mdx/runtime/next"
     }),
     getImportCode({
       type: "namespace",
-      specifier: toImportPath(configPath, outDir2),
+      specifier: toImportPath(configPath, importPath),
       name: "_source"
     })
   ];
@@ -287,11 +468,15 @@ async function generateJS(configPath, config, outputPath, configHash) {
   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}`);
+      }
       lines.unshift(
         getImportCode({
           type: "namespace",
           name: importId,
-          specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${collectionName}&hash=${configHash}`
+          specifier: `${toImportPath(file.fullPath, importPath)}?${params.join("&")}`
         })
       );
       return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
@@ -300,17 +485,17 @@ async function generateJS(configPath, config, outputPath, configHash) {
   }
   async function getMetaEntries(collection, files) {
     const items = files.map(async (file) => {
-      const source = await readFileWithCache(file.absolutePath).catch(() => "");
-      let data = source.length === 0 ? {} : JSON.parse(source);
+      const source = await readFileWithCache(file.fullPath).catch(() => "");
+      let data = source.length === 0 ? {} : parseMetaEntry(file.fullPath, source);
       if (collection?.schema) {
         data = await validate(
           collection.schema,
           data,
           {
             source,
-            path: file.absolutePath
+            path: file.fullPath
           },
-          `invalid data in ${file.absolutePath}`
+          `invalid data in ${file.fullPath}`
         );
       }
       return JSON.stringify({
@@ -328,28 +513,40 @@ async function generateJS(configPath, config, outputPath, configHash) {
           specifier: "fumadocs-mdx/runtime/async",
           names: ["_runtimeAsync", "buildConfig"]
         }),
-        "const [err, _sourceConfig] = buildConfig(_source)",
-        "if (!_sourceConfig) throw new Error(err)"
+        "const _sourceConfig = buildConfig(_source)",
+        getImportCode({
+          type: "default",
+          name: "path",
+          specifier: "node:path"
+        })
       );
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
-      const parsed = (0, import_gray_matter.default)(
-        await readFileWithCache(file.absolutePath).catch(() => "")
-      );
+      const content = await readFileWithCache(file.fullPath).catch(() => "");
+      const parsed = fumaMatter(content);
+      let data = parsed.data;
       if (collection.schema) {
-        parsed.data = await validate(
+        data = await validate(
           collection.schema,
           parsed.data,
-          { path: file.absolutePath, source: parsed.content },
-          `invalid frontmatter in ${file.absolutePath}`
+          { path: file.fullPath, source: parsed.content },
+          `invalid frontmatter in ${file.fullPath}`
         );
       }
-      return JSON.stringify({
-        info: file,
-        data: parsed.data,
-        content: parsed.content
-      });
+      let lastModified;
+      if (config.global?.lastModifiedTime === "git") {
+        lastModified = await getGitTimestamp(file.fullPath);
+      }
+      const hash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+      const infoStr = [];
+      for (const [k, v] of Object.entries({ ...file, hash })) {
+        infoStr.push(`${k}: ${JSON.stringify(v)}`);
+      }
+      infoStr.push(
+        `absolutePath: path.resolve(${JSON.stringify(file.fullPath)})`
+      );
+      return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
     });
     return Promise.all(entries2);
   }
@@ -382,148 +579,133 @@ async function generateJS(configPath, config, outputPath, configHash) {
     ...resolvedDeclares
   ].join("\n");
 }
-async function getCollectionFiles(collection) {
-  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 (0, import_fast_glob.default)(collection.files ?? "**/*", {
-        cwd: path2.resolve(dir),
-        absolute: true
-      });
-      for (const item of result) {
-        if (getTypeFromPath(item) !== collection.type) continue;
-        files.set(item, {
-          path: path2.relative(dir, item),
-          absolutePath: item
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
-}
-function getImportCode(info) {
-  const specifier = JSON.stringify(info.specifier);
-  if (info.type === "default") return `import ${info.name} from ${specifier}`;
-  if (info.type === "namespace")
-    return `import * as ${info.name} from ${specifier}`;
-  if (info.type === "named") {
-    const names = info.names.map(
-      (name) => Array.isArray(name) ? `${name[0]} as ${name[1]}` : name
-    );
-    return `import { ${names.join(", ")} } from ${specifier}`;
-  }
-  return `import ${specifier}`;
-}
-function toImportPath(file, dir) {
-  const ext = path2.extname(file);
-  let importPath = path2.relative(
-    dir,
-    ext === ".ts" ? file.substring(0, file.length - ext.length) : file
-  );
-  if (!path2.isAbsolute(importPath) && !importPath.startsWith(".")) {
-    importPath = `./${importPath}`;
+function parseMetaEntry(file, content) {
+  const extname2 = path7.extname(file);
+  try {
+    if (extname2 === ".json") return JSON.parse(content);
+    if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
+  } catch (e) {
+    throw new Error(`Failed to parse meta file: ${file}.`, {
+      cause: e
+    });
   }
-  return importPath.replaceAll(path2.sep, "/");
+  throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
-// src/map/index.ts
-async function start(dev, configPath, outDir2) {
-  void fs3.rm(path3.resolve(outDir2, `index.js`), { force: true });
-  void fs3.rm(path3.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs3.mkdir(outDir2, { recursive: true });
-  let configHash = await getConfigHash(configPath);
-  let config = await loadConfig(configPath, configHash, true);
-  const outPath = path3.resolve(outDir2, `index.ts`);
-  async function updateMapFile() {
-    console.time(`[MDX] update map file`);
-    try {
-      await fs3.writeFile(
-        outPath,
-        await generateJS(configPath, config, outPath, configHash)
-      );
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        err.print();
-      } else {
-        console.error(err);
+// 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);
       }
-    }
-    console.timeEnd(`[MDX] update map file`);
-  }
-  await updateMapFile();
-  if (dev) {
-    const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
-    const instance = watcher2(configPath, config);
-    instance.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    instance.on("all", (event, file) => {
-      if (typeof file !== "string") return;
-      const absolutePath = path3.resolve(file);
-      const onUpdate = async () => {
-        const isConfigFile = absolutePath === configPath;
-        if (isConfigFile) {
-          configHash = await getConfigHash(configPath);
-          config = await loadConfig(configPath, configHash, true);
+      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;
         }
-        if (event === "change") fileCache.removeCache(absolutePath);
-        await updateMapFile();
       };
-      void onUpdate();
-    });
-    process.on("exit", () => {
-      console.log("[MDX] closing dev server");
-      void instance.close();
-    });
-  }
+    },
+    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/create.ts
-var outDir = import_node_path2.default.resolve(".source");
+// src/next/index.ts
 var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
-function createMDX({
-  configPath = findConfigFile()
-} = {}) {
-  const isDev = process.argv.includes("dev");
-  const isBuild = process.argv.includes("build");
-  if ((isDev || isBuild) && process.env._FUMADOCS_MDX !== "1") {
+function createMDX(createOptions = {}) {
+  const options = applyDefaults(createOptions);
+  const isDev = process.env.NODE_ENV === "development";
+  if (process.env._FUMADOCS_MDX !== "1") {
     process.env._FUMADOCS_MDX = "1";
-    void start(isDev, configPath, outDir);
+    void init(isDev, options);
   }
   return (nextConfig = {}) => {
     const mdxLoaderOptions = {
-      _ctx: {
-        configPath
+      ...options,
+      isDev
+    };
+    const turbopack = {
+      ...nextConfig.turbopack,
+      rules: {
+        ...nextConfig.turbopack?.rules,
+        "*.{md,mdx}": {
+          loaders: [
+            {
+              loader: "fumadocs-mdx/loader-mdx",
+              options: mdxLoaderOptions
+            }
+          ],
+          as: "*.js"
+        }
       }
     };
     return {
       ...nextConfig,
-      turbopack: {
-        ...nextConfig?.turbopack,
-        rules: {
-          ...nextConfig?.turbopack?.rules,
-          // @ts-expect-error -- safe
-          "*.{md,mdx}": {
-            loaders: [
-              {
-                loader: "fumadocs-mdx/loader-mdx",
-                options: mdxLoaderOptions
-              }
-            ],
-            as: "*.js"
-          }
-        }
-      },
+      turbopack,
       pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
-      webpack: (config, options) => {
+      webpack: (config, options2) => {
         config.resolve ||= {};
         config.module ||= {};
         config.module.rules ||= [];
         config.module.rules.push({
           test: /\.mdx?$/,
           use: [
-            options.defaultLoaders.babel,
+            options2.defaultLoaders.babel,
             {
               loader: "fumadocs-mdx/loader-mdx",
               options: mdxLoaderOptions
@@ -531,34 +713,105 @@ function createMDX({
           ]
         });
         config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
+        return nextConfig.webpack?.(config, options2) ?? config;
       }
     };
   };
 }
-
-// src/postinstall.ts
-var path5 = __toESM(require("path"), 1);
-var fs4 = __toESM(require("fs"), 1);
-async function postInstall(configPath = findConfigFile()) {
-  const jsOut = path5.resolve(".source/index.ts");
-  const hash = await getConfigHash(configPath);
-  const config = await loadConfig(configPath, hash, true);
-  fs4.mkdirSync(path5.dirname(jsOut), { recursive: true });
-  fs4.writeFileSync(
-    jsOut,
-    await generateJS(
-      configPath,
-      config,
-      path5.resolve(".source/index.ts"),
-      hash
-    )
+async function init(dev, options) {
+  const core = createNextCore(options);
+  async function initOrReload() {
+    await core.init({
+      config: loadConfig(options.configPath, options.outDir, true)
+    });
+    await core.emitAndWrite();
+  }
+  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 {
+        watcher.add(collection.dir);
+      }
+    }
+    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 === path9.resolve(options.configPath)) {
+        watcher.removeAllListeners();
+        await watcher.close();
+        await initOrReload();
+        console.log("[MDX] restarting dev server");
+        await devServer();
+      }
+    });
+    process.on("exit", () => {
+      if (watcher.closed) return;
+      console.log("[MDX] closing dev server");
+      void watcher.close();
+    });
+    await core.initServer({ watcher });
+  }
+  await initOrReload();
+  if (dev) {
+    await devServer();
+  }
+}
+async function postInstall(configPath = findConfigFile(), outDir = ".source") {
+  const core = await createNextCore({
+    outDir,
+    configPath
+  }).init({
+    config: loadConfig(configPath, outDir, true)
+  });
+  await core.emitAndWrite();
+}
+function applyDefaults(options) {
+  return {
+    outDir: options.outDir ?? ".source",
+    configPath: options.configPath ?? findConfigFile()
+  };
+}
+function createNextCore({
+  outDir,
+  configPath
+}) {
+  const core = createCore(
+    {
+      environment: "next",
+      outDir,
+      configPath
+    },
+    [next()]
   );
-  console.log("[MDX] types generated");
+  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 = {
   createMDX,
-  postInstall,
-  start
+  postInstall
 });