fumadocs-mdx 11.6.0 → 13.0.1

package/dist/next/index.d.cts

@@ -1,21 +1,18 @@
 import { NextConfig } from 'next';
 
-/**
- * Start a MDX server that builds index and manifest files.
- *
- * In development mode, it starts a file watcher to auto-update output as your input changes.
- */
-declare function start(dev: boolean, configPath: string, outDir: string): Promise<void>;
-
 interface CreateMDXOptions {
     /**
      * Path to source configuration file
      */
     configPath?: string;
+    /**
+     * Directory for output files
+     *
+     * @defaultValue '.source'
+     */
+    outDir?: string;
 }
+declare function createMDX(createOptions?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
+declare function postInstall(configPath?: string, outDir?: string): Promise<void>;
 
-declare function createMDX({ configPath, }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
-
-declare function postInstall(configPath?: string): Promise<void>;
-
-export { type CreateMDXOptions, createMDX, postInstall, start };
+export { type CreateMDXOptions, createMDX, postInstall };

package/dist/next/index.d.ts

@@ -1,21 +1,18 @@
 import { NextConfig } from 'next';
 
-/**
- * Start a MDX server that builds index and manifest files.
- *
- * In development mode, it starts a file watcher to auto-update output as your input changes.
- */
-declare function start(dev: boolean, configPath: string, outDir: string): Promise<void>;
-
 interface CreateMDXOptions {
     /**
      * Path to source configuration file
      */
     configPath?: string;
+    /**
+     * Directory for output files
+     *
+     * @defaultValue '.source'
+     */
+    outDir?: string;
 }
+declare function createMDX(createOptions?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
+declare function postInstall(configPath?: string, outDir?: string): Promise<void>;
 
-declare function createMDX({ configPath, }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
-
-declare function postInstall(configPath?: string): Promise<void>;
-
-export { type CreateMDXOptions, createMDX, postInstall, start };
+export { type CreateMDXOptions, createMDX, postInstall };

package/dist/next/index.js

@@ -1,75 +1,103 @@
 import {
-  findConfigFile,
-  getConfigHash,
   loadConfig
-} from "../chunk-HFLDWPJA.js";
-import "../chunk-DRVUBK5B.js";
+} from "../chunk-JVZFH6ND.js";
+import {
+  getImportCode,
+  toImportPath
+} from "../chunk-CXA4JO4Z.js";
+import "../chunk-U4MQ44TS.js";
 import {
   ValidationError,
+  createCore,
+  findConfigFile,
+  getGitTimestamp,
   validate
-} from "../chunk-2ZOW45YZ.js";
-
-// src/next/create.ts
-import path3 from "node:path";
-
-// src/map/index.ts
-import * as path2 from "node:path";
-import * as fs2 from "node:fs/promises";
-
-// src/map/generate.ts
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import fg from "fast-glob";
+} from "../chunk-EELYB2XC.js";
+import {
+  fumaMatter
+} from "../chunk-VWJKRQZR.js";
+import {
+  getCollectionFiles
+} from "../chunk-XZY2AWJI.js";
 
-// src/utils/get-type-from-path.ts
-import { extname } from "node:path";
-var docTypes = [".mdx", ".md"];
-var metaTypes = [".json", ".yaml"];
-function getTypeFromPath(path5) {
-  const ext = extname(path5);
-  if (docTypes.includes(ext)) return "doc";
-  if (metaTypes.includes(ext)) return "meta";
-}
+// src/next/index.ts
+import * as path3 from "path";
 
-// src/map/file-cache.ts
+// src/next/file-cache.ts
 import { LRUCache } from "lru-cache";
+import fs from "fs/promises";
+import path from "path";
 var map = new LRUCache({
-  max: 200
+  max: 100
 });
-var fileCache = {
-  read(namespace, path5) {
-    return map.get(`${namespace}.${path5}`);
-  },
-  write(namespace, path5, data) {
-    map.set(`${namespace}.${path5}`, data);
-  },
-  removeCache(path5) {
-    for (const key of map.keys()) {
-      const keyPath = key.slice(key.indexOf(".") + 1);
-      if (keyPath === path5) map.delete(key);
-    }
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.relative(process.cwd(), file);
   }
-};
-
-// src/map/generate.ts
-import matter from "gray-matter";
+  return file;
+}
 async function readFileWithCache(file) {
-  const cached = fileCache.read("read-file", file);
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
   if (cached) return cached;
-  return (await fs.readFile(file)).toString();
+  const read = fs.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+// src/plugins/next.ts
+import * as path2 from "path";
+import { createHash } from "crypto";
+import { load } from "js-yaml";
+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 = path.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"
     })
   ];
@@ -77,11 +105,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} }`;
@@ -90,17 +122,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({
@@ -118,28 +150,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 = matter(
-        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 = 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);
   }
@@ -172,148 +216,60 @@ 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 fg(collection.files ?? "**/*", {
-        cwd: path.resolve(dir),
-        absolute: true
-      });
-      for (const item of result) {
-        if (getTypeFromPath(item) !== collection.type) continue;
-        files.set(item, {
-          path: path.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 = path.extname(file);
-  let importPath = path.relative(
-    dir,
-    ext === ".ts" ? file.substring(0, file.length - ext.length) : file
-  );
-  if (!path.isAbsolute(importPath) && !importPath.startsWith(".")) {
-    importPath = `./${importPath}`;
-  }
-  return importPath.replaceAll(path.sep, "/");
-}
-
-// src/map/index.ts
-async function start(dev, configPath, outDir2) {
-  void fs2.rm(path2.resolve(outDir2, `index.js`), { force: true });
-  void fs2.rm(path2.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs2.mkdir(outDir2, { recursive: true });
-  let configHash = await getConfigHash(configPath);
-  let config = await loadConfig(configPath, configHash, true);
-  const outPath = path2.resolve(outDir2, `index.ts`);
-  async function updateMapFile() {
-    console.time(`[MDX] update map file`);
-    try {
-      await fs2.writeFile(
-        outPath,
-        await generateJS(configPath, config, outPath, configHash)
-      );
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        err.print();
-      } else {
-        console.error(err);
-      }
-    }
-    console.timeEnd(`[MDX] update map file`);
-  }
-  await updateMapFile();
-  if (dev) {
-    const { watcher } = await import("../watcher-IAZDSTU7.js");
-    const instance = watcher(configPath, config);
-    instance.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    instance.on("all", (event, file) => {
-      if (typeof file !== "string") return;
-      const absolutePath = path2.resolve(file);
-      const onUpdate = async () => {
-        const isConfigFile = absolutePath === configPath;
-        if (isConfigFile) {
-          configHash = await getConfigHash(configPath);
-          config = await loadConfig(configPath, configHash, true);
-        }
-        if (event === "change") fileCache.removeCache(absolutePath);
-        await updateMapFile();
-      };
-      void onUpdate();
-    });
-    process.on("exit", () => {
-      console.log("[MDX] closing dev server");
-      void instance.close();
+function parseMetaEntry(file, content) {
+  const extname2 = path2.extname(file);
+  try {
+    if (extname2 === ".json") return JSON.parse(content);
+    if (extname2 === ".yaml") return load(content);
+  } catch (e) {
+    throw new Error(`Failed to parse meta file: ${file}.`, {
+      cause: e
     });
   }
+  throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
-// src/next/create.ts
-var outDir = path3.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
@@ -321,33 +277,104 @@ function createMDX({
           ]
         });
         config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
+        return nextConfig.webpack?.(config, options2) ?? config;
       }
     };
   };
 }
-
-// src/postinstall.ts
-import * as path4 from "node:path";
-import * as fs3 from "node:fs";
-async function postInstall(configPath = findConfigFile()) {
-  const jsOut = path4.resolve(".source/index.ts");
-  const hash = await getConfigHash(configPath);
-  const config = await loadConfig(configPath, hash, true);
-  fs3.mkdirSync(path4.dirname(jsOut), { recursive: true });
-  fs3.writeFileSync(
-    jsOut,
-    await generateJS(
-      configPath,
-      config,
-      path4.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 = path3.resolve(file);
+      if (event === "change") removeFileCache(absolutePath);
+      if (absolutePath === path3.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);
+        }
+      }
+    }
+  };
 }
 export {
   createMDX,
-  postInstall,
-  start
+  postInstall
 };