fumadocs-mdx 14.0.0 → 14.0.1

package/dist/bun/index.cjs

@@ -763,24 +763,7 @@ var import_node_url2 = require("url");
 
 // src/core.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var import_promises3 = __toESM(require("fs/promises"), 1);
-
-// src/utils/codegen/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;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
 
 // src/utils/validation.ts
 var ValidationError = class extends Error {
@@ -820,6 +803,13 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
+// src/utils/codegen.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_tinyglobby = require("tinyglobby");
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
 // src/core.ts
 var _Defaults = {
   configPath: "source.config.ts",
@@ -853,7 +843,6 @@ function createCore(options, defaultPlugins = []) {
     return data;
   }
   const core = {
-    _options: options,
     /**
      * Convenient cache store, reset when config changes
      */
@@ -862,6 +851,7 @@ function createCore(options, defaultPlugins = []) {
       config = await newConfig;
       this.cache.clear();
       plugins = await getPlugins([
+        postprocessPlugin(),
         ...defaultPlugins,
         ...config.global.plugins ?? []
       ]);
@@ -869,7 +859,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;
@@ -880,10 +872,13 @@ function createCore(options, defaultPlugins = []) {
     getCompiledConfigPath() {
       return import_node_path3.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);
       }
@@ -902,8 +897,8 @@ function createCore(options, defaultPlugins = []) {
       await Promise.all(
         out.map(async (entry) => {
           const file = import_node_path3.default.join(options.outDir, entry.path);
-          await import_promises3.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
-          await import_promises3.default.writeFile(file, entry.content);
+          await import_promises2.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+          await import_promises2.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start}ms`);
@@ -950,9 +945,48 @@ function createCore(options, defaultPlugins = []) {
   };
   return core;
 }
+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");
+      }
+    }
+  };
+}
 
 // src/loaders/config.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
 function createIntegratedConfigLoader(core) {
   return {
     core,
@@ -1042,7 +1076,7 @@ function createMetaLoader(configLoader, resolve2 = {}) {
 
 // src/loaders/adapter.ts
 var import_node_url = require("url");
-var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
 var import_node_path4 = __toESM(require("path"), 1);
 var import_node_fs = require("fs");
@@ -1093,11 +1127,12 @@ function createMdxPlugin(options = {}) {
     name: "bun-plugin-fumadocs-mdx",
     async setup(build) {
       const importPath = (0, import_node_url2.pathToFileURL)(configPath).href;
-      const core = await createCore({
+      const core = createCore({
         environment,
         outDir,
         configPath
-      }).init({
+      });
+      await core.init({
         config: buildConfig(await import(importPath))
       });
       const configLoader = createIntegratedConfigLoader(core);

package/dist/bun/index.d.cts

@@ -1,5 +1,5 @@
 import { BunPlugin } from 'bun';
-import { C as CoreOptions } from '../index-D7JdSMpp.cjs';
+import { i as CoreOptions } from '../core-DTuP23zu.cjs';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
 import 'unified';
@@ -7,6 +7,12 @@ import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
 import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.cjs';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
 
 interface MdxPluginOptions extends Partial<CoreOptions> {
     /**

package/dist/bun/index.d.ts

@@ -1,5 +1,5 @@
 import { BunPlugin } from 'bun';
-import { C as CoreOptions } from '../index-D7JdSMpp.js';
+import { i as CoreOptions } from '../core-B9ZoS6sA.js';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
 import 'unified';
@@ -7,6 +7,12 @@ import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
 import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.js';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
 
 interface MdxPluginOptions extends Partial<CoreOptions> {
     /**

package/dist/bun/index.js

@@ -11,13 +11,13 @@ import {
 import {
   createIntegratedConfigLoader,
   toBun
-} from "../chunk-SRSRFOVI.js";
+} from "../chunk-K6HCOGOX.js";
 import "../chunk-4JSFLXXT.js";
 import {
   _Defaults,
   createCore
-} from "../chunk-7L2KNF6B.js";
-import "../chunk-PKI7ZDA5.js";
+} from "../chunk-BEBCWQC7.js";
+import "../chunk-WBIHDYMN.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/bun/index.ts
@@ -33,11 +33,12 @@ function createMdxPlugin(options = {}) {
     name: "bun-plugin-fumadocs-mdx",
     async setup(build) {
       const importPath = pathToFileURL(configPath).href;
-      const core = await createCore({
+      const core = createCore({
         environment,
         outDir,
         configPath
-      }).init({
+      });
+      await core.init({
         config: buildConfig(await import(importPath))
       });
       const configLoader = createIntegratedConfigLoader(core);

package/dist/{chunk-5YXP7JLN.js → chunk-5OBUOALK.js}

@@ -1,6 +1,7 @@
 // src/runtime/server.ts
 import * as path from "path";
-function fromConfig() {
+function server(options = {}) {
+  const { doc: { passthroughs: docPassthroughs = [] } = {} } = options;
   function fileInfo(file, base) {
     if (file.startsWith("./")) {
       file = file.slice(2);
@@ -11,14 +12,16 @@ function fromConfig() {
     };
   }
   function mapDocData(entry) {
-    return {
+    const data = {
       body: entry.default,
       toc: entry.toc,
-      extractedReferences: entry.extractedReferences,
       structuredData: entry.structuredData,
-      lastModified: entry.lastModified,
       _exports: entry
     };
+    for (const key of docPassthroughs) {
+      data[key] = entry[key];
+    }
+    return data;
   }
   return {
     async doc(_name, base, glob) {
@@ -133,6 +136,6 @@ function createDocMethods(info, load) {
 }
 
 export {
-  fromConfig,
+  server,
   toFumadocsSource
 };

package/dist/{chunk-XHJCLBZ4.js → chunk-7UKSZSPY.js}

@@ -1,137 +1,41 @@
 import {
-  readFileWithCache
-} from "./chunk-PKI7ZDA5.js";
+  createCodegen,
+  ident
+} from "./chunk-WBIHDYMN.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
 
 // src/plugins/index-file.ts
 import path2 from "path";
+import { glob } from "tinyglobby";
 
-// src/utils/codegen/index.ts
+// src/utils/fs-cache.ts
+import { LRUCache } from "lru-cache";
+import fs from "fs/promises";
 import path from "path";
-import { glob } from "tinyglobby";
-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" />');
+var map = new LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.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(path.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 = glob(patterns, {
-          cwd: base
-        });
-        globCache.set(cacheKey, files);
-      }
-      let code = "{";
-      for (const item of await files) {
-        const fullPath = path.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 = path.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(path.relative(outDir, filename));
-      return importPath.startsWith(".") ? importPath : `./${importPath}`;
-    },
-    toString() {
-      return [...banner, ...this.lines].join("\n");
-    }
-  };
+  return file;
 }
-function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+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 slash(path3) {
-  const isExtendedLengthPath = path3.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path3;
-  }
-  return path3.replaceAll("\\", "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
 }
 
 // src/plugins/index-file.ts
-import { glob as glob2 } from "tinyglobby";
 import { createHash } from "crypto";
 function indexFile(options = {}) {
   const {
@@ -145,6 +49,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) {
@@ -154,6 +77,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;
@@ -173,48 +97,47 @@ function indexFile(options = {}) {
     },
     async emit() {
       const globCache = /* @__PURE__ */ new Map();
-      const makeCodeGen = () => createCodegen({
-        target,
-        outDir: this.outDir,
-        jsExtension: addJsExtension,
-        globCache
-      });
-      async function toEmitEntry(path3, content) {
+      const { serverOptions, tc } = generateConfigs(this.core);
+      const toEmitEntry = async (path3, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir: this.outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc
+        });
         return {
           path: path3,
-          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) {
@@ -261,22 +184,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 = path2.join(collection.dir, file);
@@ -312,7 +239,7 @@ async function generateDynamicIndexFile(core, codegen) {
     if (parent.type === "doc") collection = parent;
     else if (parent.type === "docs") collection = parent.docs;
     if (!collection || !collection.dynamic) return;
-    const files = await glob2(collection.patterns, {
+    const files = await glob(collection.patterns, {
       cwd: collection.dir
     });
     const entries = await Promise.all(
@@ -339,14 +266,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) {
@@ -361,14 +287,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, {