fumadocs-mdx 12.0.3 → 13.0.0

package/dist/next/index.js

@@ -1,7 +1,3 @@
-import {
-  readFileWithCache,
-  removeFileCache
-} from "../chunk-ADR6R7HM.js";
 import {
   getGlobPatterns,
   getImportCode,
@@ -9,32 +5,74 @@ import {
   toImportPath
 } from "../chunk-6Y5JDZHD.js";
 import {
-  getConfigHash,
   loadConfig
-} from "../chunk-LGYVNESJ.js";
+} from "../chunk-JVZFH6ND.js";
 import "../chunk-U4MQ44TS.js";
 import {
   ValidationError,
+  findConfigFile,
   getGitTimestamp,
   validate
-} from "../chunk-IQAEAI4P.js";
-import {
-  findConfigFile
-} from "../chunk-XMFLD5J6.js";
+} from "../chunk-HI62EXSB.js";
 import {
   fumaMatter
 } from "../chunk-VWJKRQZR.js";
+import {
+  createPluginHandler
+} from "../chunk-4MAYA5QX.js";
 
 // src/next/index.ts
-import path3 from "path";
-import fs2 from "fs/promises";
+import * as path3 from "path";
 
-// src/next/map/generate.ts
-import * as path from "path";
+// src/next/file-cache.ts
+import { LRUCache } from "lru-cache";
+import fs from "fs/promises";
+import path from "path";
+var map = new LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.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 = 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 { glob } from "tinyglobby";
 import { load } from "js-yaml";
-async function generateJS(configPath, config, importPath, configHash = false) {
+function next() {
+  let config;
+  return {
+    config(v) {
+      config = v;
+    },
+    async emit() {
+      return [
+        {
+          path: "index.ts",
+          content: await indexFile(this.configPath, config, {
+            relativeTo: this.outDir
+          })
+        }
+      ];
+    }
+  };
+}
+async function indexFile(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
     getImportCode({
@@ -170,11 +208,11 @@ async function getCollectionFiles(collection) {
   await Promise.all(
     dirs.map(async (dir) => {
       const result = await glob(patterns, {
-        cwd: path.resolve(dir)
+        cwd: path2.resolve(dir)
       });
       for (const item of result) {
         if (!isFileSupported(item, collection)) continue;
-        const fullPath = path.join(dir, item);
+        const fullPath = path2.join(dir, item);
         files.set(fullPath, {
           path: item,
           fullPath
@@ -185,7 +223,7 @@ async function getCollectionFiles(collection) {
   return Array.from(files.values());
 }
 function parseMetaEntry(file, content) {
-  const extname2 = path.extname(file);
+  const extname2 = path2.extname(file);
   try {
     if (extname2 === ".json") return JSON.parse(content);
     if (extname2 === ".yaml") return load(content);
@@ -197,91 +235,23 @@ function parseMetaEntry(file, content) {
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
 
-// src/next/map/index.ts
-import * as path2 from "path";
-import * as fs from "fs/promises";
-async function start(dev, configPath, outDir) {
-  let configHash = await getConfigHash(configPath);
-  let config = await loadConfig(configPath, outDir, configHash, true);
-  const outPath = path2.resolve(outDir, `index.ts`);
-  async function updateMapFile() {
-    const start2 = performance.now();
-    try {
-      await fs.writeFile(
-        outPath,
-        await generateJS(
-          configPath,
-          config,
-          { relativeTo: outDir },
-          configHash
-        )
-      );
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        console.error(err.toStringFormatted());
-      } else {
-        console.error(err);
-      }
-    }
-    console.log(`[MDX] updated map file in ${performance.now() - start2}ms`);
-  }
-  await updateMapFile();
-  if (dev) {
-    const { watcher } = await import("../watcher-HGOH3APP.js");
-    const instance = watcher(configPath, config, [outPath]);
-    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, outDir, configHash, true);
-        }
-        if (event === "change") removeFileCache(absolutePath);
-        await updateMapFile();
-      };
-      void onUpdate();
-    });
-    process.on("exit", () => {
-      console.log("[MDX] closing dev server");
-      void instance.close();
-    });
-  }
-}
-
-// src/next/create.ts
-import { readFileSync } from "fs";
+// src/next/index.ts
 var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
-var isTurboExperimental;
-try {
-  const content = readFileSync("./node_modules/next/package.json").toString();
-  const version = JSON.parse(content).version;
-  isTurboExperimental = version.startsWith("15.0.") || version.startsWith("15.1.") || version.startsWith("15.2.");
-} catch {
-  isTurboExperimental = false;
-}
-function createMDX({
-  configPath = findConfigFile(),
-  outDir = ".source"
-} = {}) {
+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(process.env.NODE_ENV === "development", configPath, outDir);
+    void init(isDev, options);
   }
   return (nextConfig = {}) => {
     const mdxLoaderOptions = {
-      configPath,
-      outDir
+      ...options,
+      isDev
     };
-    const turbo = {
-      ...nextConfig.experimental?.turbo,
+    const turbopack = {
       ...nextConfig.turbopack,
       rules: {
-        ...nextConfig.experimental?.turbo?.rules,
         ...nextConfig.turbopack?.rules,
         "*.{md,mdx}": {
           loaders: [
@@ -294,17 +264,18 @@ function createMDX({
         }
       }
     };
-    const updated = {
+    return {
       ...nextConfig,
+      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
@@ -312,33 +283,90 @@ function createMDX({
           ]
         });
         config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
+        return nextConfig.webpack?.(config, options2) ?? config;
       }
     };
-    if (isTurboExperimental) {
-      updated.experimental = { ...updated.experimental, turbo };
-    } else {
-      updated.turbopack = turbo;
-    }
-    return updated;
   };
 }
-
-// src/next/index.ts
+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)
+    );
+  }
+  async function emitFiles() {
+    const start = performance.now();
+    try {
+      await pluginHandler.emitAndWrite();
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        console.error(err.toStringFormatted());
+      } else {
+        console.error(err);
+      }
+    }
+    console.log(`[MDX] updated map file in ${performance.now() - start}ms`);
+  }
+  async function devServer() {
+    const { watcher } = await import("../watcher-WXJDWRZY.js");
+    const instance = watcher(options.configPath, config, [options.outDir]);
+    async function onUpdate(event, file) {
+      const absolutePath = path3.resolve(file);
+      if (event === "change") removeFileCache(absolutePath);
+      if (absolutePath === path3.resolve(options.configPath)) {
+        await updateConfig();
+        console.log("[MDX] restarting dev server");
+        await instance.close();
+        void devServer();
+      }
+      await emitFiles();
+    }
+    instance.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    instance.on("all", (event, file) => {
+      void onUpdate(event, file);
+    });
+    process.on("exit", () => {
+      console.log("[MDX] closing dev server");
+      void instance.close();
+    });
+  }
+  await updateConfig();
+  await emitFiles();
+  if (dev) void devServer();
+}
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
-  const config = await loadConfig(configPath, outDir, void 0, true);
-  const outPath = path3.join(outDir, "index.ts");
-  await fs2.rm(outDir, { recursive: true });
-  await fs2.mkdir(outDir, { recursive: true });
-  const hash = await getConfigHash(configPath);
-  await fs2.writeFile(
-    outPath,
-    await generateJS(configPath, config, { relativeTo: outDir }, hash)
-  );
+  const pluginHandler = createNextPluginHandler({
+    outDir,
+    configPath
+  });
+  await pluginHandler.init(await loadConfig(configPath, outDir, true));
+  await pluginHandler.emitAndWrite();
   console.log("[MDX] types generated");
 }
+function applyDefaults(options) {
+  return {
+    outDir: options.outDir ?? ".source",
+    configPath: options.configPath ?? findConfigFile()
+  };
+}
+function createNextPluginHandler({
+  outDir,
+  configPath
+}) {
+  return createPluginHandler(
+    {
+      environment: "next",
+      outDir,
+      configPath
+    },
+    [next()]
+  );
+}
 export {
   createMDX,
-  postInstall,
-  start
+  postInstall
 };