fumadocs-mdx 14.0.0 → 14.0.1

package/dist/bin.cjs

@@ -229,10 +229,11 @@ __export(load_from_file_exports, {
 });
 async function compileConfig(core) {
   const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
   const transformed = await build({
-    entryPoints: [{ in: core._options.configPath, out: "source.config" }],
+    entryPoints: [{ in: configPath, out: "source.config" }],
     bundle: true,
-    outdir: core._options.outDir,
+    outdir: outDir,
     target: "node20",
     write: true,
     platform: "node",
@@ -309,34 +310,131 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
   }
 });
 
-// src/utils/codegen/cache.ts
-function toFullPath(file) {
-  if (import_node_path.default.isAbsolute(file)) {
-    return import_node_path.default.relative(process.cwd(), file);
+// src/utils/codegen.ts
+function createCodegen({
+  target = "default",
+  outDir = "",
+  jsExtension = false,
+  globCache = /* @__PURE__ */ new Map()
+}) {
+  let eagerImportId = 0;
+  const banner = ["// @ts-nocheck"];
+  if (target === "vite") {
+    banner.push('/// <reference types="vite/client" />');
   }
-  return file;
+  return {
+    options: {
+      target,
+      outDir
+    },
+    lines: [],
+    addImport(statement) {
+      this.lines.unshift(statement);
+    },
+    async pushAsync(insert) {
+      for (const line of await Promise.all(insert)) {
+        if (line === void 0) continue;
+        this.lines.push(line);
+      }
+    },
+    async generateGlobImport(patterns, options) {
+      if (target === "vite") {
+        return this.generateViteGlobImport(patterns, options);
+      }
+      return this.generateNodeGlobImport(patterns, options);
+    },
+    generateViteGlobImport(patterns, { base, ...rest }) {
+      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+        normalizeViteGlobPath
+      );
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          base: normalizeViteGlobPath(import_node_path.default.relative(outDir, base)),
+          ...rest
+        },
+        null,
+        2
+      )})`;
+    },
+    async generateNodeGlobImport(patterns, {
+      base,
+      eager = false,
+      query = {},
+      import: importName
+    }) {
+      const cacheKey = JSON.stringify({ patterns, base });
+      let files = globCache.get(cacheKey);
+      if (!files) {
+        files = (0, import_tinyglobby.glob)(patterns, {
+          cwd: base
+        });
+        globCache.set(cacheKey, files);
+      }
+      let code = "{";
+      for (const item of await files) {
+        const fullPath = import_node_path.default.join(base, item);
+        const searchParams = new URLSearchParams();
+        for (const [k, v] of Object.entries(query)) {
+          searchParams.set(k, v);
+        }
+        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
+        if (eager) {
+          const name = `__fd_glob_${eagerImportId++}`;
+          this.lines.unshift(
+            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+          );
+          code += `${JSON.stringify(item)}: ${name}, `;
+        } else {
+          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+          if (importName) {
+            line += `.then(mod => mod.${importName})`;
+          }
+          code += `${line}, `;
+        }
+      }
+      code += "}";
+      return code;
+    },
+    formatImportPath(file) {
+      const ext = import_node_path.default.extname(file);
+      let filename;
+      if (ext === ".ts" && 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;
+      }
+      const importPath = slash(import_node_path.default.relative(outDir, filename));
+      return importPath.startsWith(".") ? importPath : `./${importPath}`;
+    },
+    toString() {
+      return [...banner, ...this.lines].join("\n");
+    }
+  };
 }
-async function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
 }
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
+function slash(path9) {
+  const isExtendedLengthPath = path9.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path9;
+  }
+  return path9.replaceAll("\\", "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_lru_cache, import_promises, import_node_path, map;
-var init_cache = __esm({
-  "src/utils/codegen/cache.ts"() {
+var import_node_path, import_tinyglobby;
+var init_codegen = __esm({
+  "src/utils/codegen.ts"() {
     "use strict";
-    import_lru_cache = require("lru-cache");
-    import_promises = __toESM(require("fs/promises"), 1);
     import_node_path = __toESM(require("path"), 1);
-    map = new import_lru_cache.LRUCache({
-      max: 100
-    });
+    import_tinyglobby = require("tinyglobby");
   }
 });
 
@@ -369,7 +467,6 @@ function createCore(options, defaultPlugins = []) {
     return data;
   }
   const core = {
-    _options: options,
     /**
      * Convenient cache store, reset when config changes
      */
@@ -378,6 +475,7 @@ function createCore(options, defaultPlugins = []) {
       config = await newConfig;
       this.cache.clear();
       plugins = await getPlugins([
+        postprocessPlugin(),
         ...defaultPlugins,
         ...config.global.plugins ?? []
       ]);
@@ -385,7 +483,9 @@ function createCore(options, defaultPlugins = []) {
         const out = await plugin.config?.call(pluginContext, config);
         if (out) config = out;
       }
-      return this;
+    },
+    getOptions() {
+      return options;
     },
     getConfig() {
       return config;
@@ -396,10 +496,13 @@ function createCore(options, defaultPlugins = []) {
     getCompiledConfigPath() {
       return import_node_path2.default.join(options.outDir, "source.config.mjs");
     },
+    getPlugins() {
+      return plugins;
+    },
+    getPluginContext() {
+      return pluginContext;
+    },
     async initServer(server) {
-      server.watcher?.on("all", async (event, file) => {
-        if (event === "change") removeFileCache(file);
-      });
       for (const plugin of plugins) {
         await plugin.configureServer?.call(pluginContext, server);
       }
@@ -418,8 +521,8 @@ function createCore(options, defaultPlugins = []) {
       await Promise.all(
         out.map(async (entry) => {
           const file = import_node_path2.default.join(options.outDir, entry.path);
-          await import_promises2.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-          await import_promises2.default.writeFile(file, entry.content);
+          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+          await import_promises.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start2}ms`);
@@ -466,14 +569,53 @@ function createCore(options, defaultPlugins = []) {
   };
   return core;
 }
-var import_node_path2, import_promises2, _Defaults;
+function postprocessPlugin() {
+  const LinkReferenceTypes = `{
+  /**
+   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+   */
+  extractedReferences?: import('fumadocs-mdx').ExtractedReference[];
+}`;
+  return {
+    "index-file": {
+      generateTypeConfig() {
+        const lines = [];
+        lines.push("{");
+        lines.push("  DocData: {");
+        for (const collection of this.core.getConfig().collectionList) {
+          let postprocessOptions;
+          switch (collection.type) {
+            case "doc":
+              postprocessOptions = collection.postprocess;
+              break;
+            case "docs":
+              postprocessOptions = collection.docs.postprocess;
+              break;
+          }
+          if (postprocessOptions?.extractLinkReferences) {
+            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
+          }
+        }
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      },
+      serverOptions(options) {
+        options.doc ??= {};
+        options.doc.passthroughs ??= [];
+        options.doc.passthroughs.push("extractedReferences");
+      }
+    }
+  };
+}
+var import_node_path2, import_promises, _Defaults;
 var init_core = __esm({
   "src/core.ts"() {
     "use strict";
     import_node_path2 = __toESM(require("path"), 1);
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    init_cache();
+    import_promises = __toESM(require("fs/promises"), 1);
     init_validation();
+    init_codegen();
     _Defaults = {
       configPath: "source.config.ts",
       outDir: ".source"
@@ -491,131 +633,34 @@ var init_loaders = __esm({
   }
 });
 
-// src/utils/codegen/index.ts
-function createCodegen({
-  target = "default",
-  outDir = "",
-  jsExtension = false,
-  globCache = /* @__PURE__ */ new Map()
-}) {
-  let eagerImportId = 0;
-  const banner = ["// @ts-nocheck"];
-  if (target === "vite") {
-    banner.push('/// <reference types="vite/client" />');
+// src/utils/fs-cache.ts
+function toFullPath(file) {
+  if (import_node_path3.default.isAbsolute(file)) {
+    return import_node_path3.default.relative(process.cwd(), file);
   }
-  return {
-    options: {
-      target,
-      outDir
-    },
-    lines: [],
-    addImport(statement) {
-      this.lines.unshift(statement);
-    },
-    async pushAsync(insert) {
-      for (const line of await Promise.all(insert)) {
-        if (line === void 0) continue;
-        this.lines.push(line);
-      }
-    },
-    async generateGlobImport(patterns, options) {
-      if (target === "vite") {
-        return this.generateViteGlobImport(patterns, options);
-      }
-      return this.generateNodeGlobImport(patterns, options);
-    },
-    generateViteGlobImport(patterns, { base, ...rest }) {
-      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
-        normalizeViteGlobPath
-      );
-      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
-        {
-          base: normalizeViteGlobPath(import_node_path3.default.relative(outDir, base)),
-          ...rest
-        },
-        null,
-        2
-      )})`;
-    },
-    async generateNodeGlobImport(patterns, {
-      base,
-      eager = false,
-      query = {},
-      import: importName
-    }) {
-      const cacheKey = JSON.stringify({ patterns, base });
-      let files = globCache.get(cacheKey);
-      if (!files) {
-        files = (0, import_tinyglobby.glob)(patterns, {
-          cwd: base
-        });
-        globCache.set(cacheKey, files);
-      }
-      let code = "{";
-      for (const item of await files) {
-        const fullPath = import_node_path3.default.join(base, item);
-        const searchParams = new URLSearchParams();
-        for (const [k, v] of Object.entries(query)) {
-          searchParams.set(k, v);
-        }
-        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
-        if (eager) {
-          const name = `__fd_glob_${eagerImportId++}`;
-          this.lines.unshift(
-            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
-          );
-          code += `${JSON.stringify(item)}: ${name}, `;
-        } else {
-          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
-          if (importName) {
-            line += `.then(mod => mod.${importName})`;
-          }
-          code += `${line}, `;
-        }
-      }
-      code += "}";
-      return code;
-    },
-    formatImportPath(file) {
-      const ext = import_node_path3.default.extname(file);
-      let filename;
-      if (ext === ".ts" && 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;
-      }
-      const importPath = slash(import_node_path3.default.relative(outDir, filename));
-      return importPath.startsWith(".") ? importPath : `./${importPath}`;
-    },
-    toString() {
-      return [...banner, ...this.lines].join("\n");
-    }
-  };
-}
-function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+  return file;
 }
-function slash(path9) {
-  const isExtendedLengthPath = path9.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path9;
-  }
-  return path9.replaceAll("\\", "/");
+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 ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
 }
-var import_node_path3, import_tinyglobby;
-var init_codegen = __esm({
-  "src/utils/codegen/index.ts"() {
+var import_lru_cache, import_promises2, import_node_path3, map;
+var init_fs_cache = __esm({
+  "src/utils/fs-cache.ts"() {
     "use strict";
+    import_lru_cache = require("lru-cache");
+    import_promises2 = __toESM(require("fs/promises"), 1);
     import_node_path3 = __toESM(require("path"), 1);
-    import_tinyglobby = require("tinyglobby");
+    map = new import_lru_cache.LRUCache({
+      max: 100
+    });
   }
 });
 
@@ -654,6 +699,25 @@ function indexFile(options = {}) {
   function isDynamic(collection) {
     return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
   }
+  function generateConfigs(core) {
+    const serverOptions = {};
+    const typeConfigs = [];
+    const ctx = core.getPluginContext();
+    for (const plugin of core.getPlugins()) {
+      const indexFilePlugin = plugin["index-file"];
+      if (!indexFilePlugin) continue;
+      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
+      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config2) typeConfigs.push(config2);
+    }
+    if (typeConfigs.length === 0) {
+      typeConfigs.push("{ DocData: {} }");
+    }
+    return {
+      serverOptions,
+      tc: typeConfigs.join(" & ")
+    };
+  }
   return {
     name: "index-file",
     config(v) {
@@ -663,6 +727,7 @@ function indexFile(options = {}) {
     configureServer(server) {
       if (!server.watcher) return;
       server.watcher.on("all", async (event, file) => {
+        removeFileCache(file);
         if (dynamicCollections.length === 0) {
           if (target === "vite") return;
           if (target === "default" && event === "change") return;
@@ -682,48 +747,47 @@ function indexFile(options = {}) {
     },
     async emit() {
       const globCache = /* @__PURE__ */ new Map();
-      const makeCodeGen = () => createCodegen({
-        target,
-        outDir: this.outDir,
-        jsExtension: addJsExtension,
-        globCache
-      });
-      async function toEmitEntry(path9, content) {
+      const { serverOptions, tc } = generateConfigs(this.core);
+      const toEmitEntry = async (path9, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir: this.outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc
+        });
         return {
           path: path9,
-          content: await content
+          content: codegen.toString()
         };
-      }
+      };
       const out = [
-        toEmitEntry(
-          "server.ts",
-          generateServerIndexFile(makeCodeGen(), config, this.configPath)
-        )
+        toEmitEntry("server.ts", generateServerIndexFile)
       ];
       if (dynamic)
-        out.push(
-          toEmitEntry(
-            "dynamic.ts",
-            generateDynamicIndexFile(this.core, makeCodeGen())
-          )
-        );
+        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
       if (browser)
-        out.push(
-          toEmitEntry(
-            "browser.ts",
-            generateBrowserIndexFile(makeCodeGen(), config, this.configPath)
-          )
-        );
+        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
       return await Promise.all(out);
     }
   };
 }
-async function generateServerIndexFile(codegen, config, configPath) {
+async function generateServerIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
   codegen.lines.push(
-    `import { fromConfig } from 'fumadocs-mdx/runtime/server';`,
-    `import type * as Config from '${codegen.formatImportPath(configPath)}';`,
+    `import { server } from 'fumadocs-mdx/runtime/server';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
     "",
-    `const create = fromConfig<typeof Config>();`
+    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
   );
   async function generateCollectionObject(collection) {
     switch (collection.type) {
@@ -770,22 +834,26 @@ async function generateServerIndexFile(codegen, config, configPath) {
     }
   }
   await codegen.pushAsync(
-    config.collectionList.map(async (collection) => {
+    core.getConfig().collectionList.map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return `
 export const ${collection.name} = ${obj};`;
     })
   );
-  return codegen.toString();
 }
-async function generateDynamicIndexFile(core, codegen) {
-  const { configPath } = core._options;
+async function generateDynamicIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
+  const { configPath } = core.getOptions();
   codegen.lines.push(
-    `import { fromConfigDynamic } from 'fumadocs-mdx/runtime/dynamic';`,
+    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
     `import * as Config from '${codegen.formatImportPath(configPath)}';`,
     "",
-    `const create = await fromConfigDynamic(Config);`
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(core.getOptions())}, ${JSON.stringify(serverOptions)});`
   );
   async function generateCollectionObjectEntry(collection, file) {
     const fullPath = import_path.default.join(collection.dir, file);
@@ -848,14 +916,13 @@ async function generateDynamicIndexFile(core, codegen) {
 export const ${collection.name} = ${obj};`;
     })
   );
-  return codegen.toString();
 }
-async function generateBrowserIndexFile(codegen, config, configPath) {
+async function generateBrowserIndexFile({ core, codegen, tc }) {
   codegen.lines.push(
-    `import { fromConfig } from 'fumadocs-mdx/runtime/browser';`,
-    `import type * as Config from '${codegen.formatImportPath(configPath)}';`,
+    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
     "",
-    `const create = fromConfig<typeof Config>();`
+    `const create = browser<typeof Config, ${tc}>();`
   );
   async function generateCollectionObject(collection) {
     switch (collection.type) {
@@ -870,14 +937,13 @@ async function generateBrowserIndexFile(codegen, config, configPath) {
   }
   codegen.lines.push("const browserCollections = {");
   await codegen.pushAsync(
-    config.collectionList.map(async (collection) => {
+    core.getConfig().collectionList.map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return ident(`${collection.name}: ${obj},`);
     })
   );
   codegen.lines.push("};", "export default browserCollections;");
-  return codegen.toString();
 }
 function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
@@ -916,7 +982,7 @@ var init_index_file = __esm({
     import_path = __toESM(require("path"), 1);
     init_codegen();
     import_tinyglobby2 = require("tinyglobby");
-    init_cache();
+    init_fs_cache();
     import_crypto = require("crypto");
     init_fuma_matter();
   }
@@ -937,7 +1003,7 @@ function createMDX(createOptions = {}) {
   }
   return (nextConfig = {}) => {
     const loaderOptions = {
-      ...core._options,
+      ...core.getOptions(),
       compiledConfigPath: core.getCompiledConfigPath(),
       isDev
     };
@@ -1019,12 +1085,13 @@ async function init(dev, core) {
   }
   async function devServer() {
     const { FSWatcher } = await import("chokidar");
+    const { configPath, outDir } = core.getOptions();
     const watcher = new FSWatcher({
       ignoreInitial: true,
       persistent: true,
-      ignored: [core._options.outDir]
+      ignored: [outDir]
     });
-    watcher.add(core._options.configPath);
+    watcher.add(configPath);
     for (const collection of core.getConfig().collectionList) {
       if (collection.type === "docs") {
         watcher.add(collection.docs.dir);
@@ -1036,8 +1103,9 @@ async function init(dev, core) {
     watcher.on("ready", () => {
       console.log("[MDX] started dev server");
     });
+    const absoluteConfigPath = path5.resolve(configPath);
     watcher.on("all", async (_event, file) => {
-      if (path5.resolve(file) === path5.resolve(core._options.configPath)) {
+      if (path5.resolve(file) === absoluteConfigPath) {
         watcher.removeAllListeners();
         await watcher.close();
         await initOrReload();
@@ -1768,7 +1836,8 @@ __export(vite_exports, {
 });
 async function mdx(config, pluginOptions = {}) {
   const options = applyDefaults2(pluginOptions);
-  const core = await createViteCore(options).init({
+  const core = createViteCore(options);
+  await core.init({
     config: buildConfig(config)
   });
   const configLoader = createIntegratedConfigLoader(core);