fumadocs-mdx 13.0.7 → 14.0.0

package/dist/bun/index.d.cts

@@ -1,11 +1,12 @@
 import { BunPlugin } from 'bun';
-import { h as CoreOptions } from '../core-HkAVGq_a.cjs';
+import { C as CoreOptions } from '../index-D7JdSMpp.cjs';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
-import 'fumadocs-core/mdx-plugins';
 import 'unified';
+import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
+import 'vfile';
 
 interface MdxPluginOptions extends Partial<CoreOptions> {
     /**

package/dist/bun/index.d.ts

@@ -1,11 +1,12 @@
 import { BunPlugin } from 'bun';
-import { h as CoreOptions } from '../core-HkAVGq_a.js';
+import { C as CoreOptions } from '../index-D7JdSMpp.js';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
-import 'fumadocs-core/mdx-plugins';
 import 'unified';
+import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
+import 'vfile';
 
 interface MdxPluginOptions extends Partial<CoreOptions> {
     /**

package/dist/bun/index.js

@@ -1,23 +1,23 @@
 import {
   buildConfig
-} from "../chunk-2HXTGJBI.js";
+} from "../chunk-ZY6UZ7NH.js";
+import "../chunk-E5DJTSIM.js";
 import {
   createMdxLoader
-} from "../chunk-2E2JCOSO.js";
+} from "../chunk-6NISOLQ6.js";
 import {
   createMetaLoader
-} from "../chunk-4757L6ST.js";
+} from "../chunk-TYJDYTKH.js";
 import {
   createIntegratedConfigLoader,
   toBun
-} from "../chunk-ETIN2W7C.js";
-import "../chunk-3J3WL7WN.js";
-import "../chunk-K5ZLPEIQ.js";
-import "../chunk-VUEZTR2H.js";
+} from "../chunk-SRSRFOVI.js";
+import "../chunk-4JSFLXXT.js";
 import {
-  createCore,
-  findConfigFile
-} from "../chunk-2AQRQXSO.js";
+  _Defaults,
+  createCore
+} from "../chunk-7L2KNF6B.js";
+import "../chunk-PKI7ZDA5.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/bun/index.ts
@@ -25,8 +25,8 @@ import { pathToFileURL } from "url";
 function createMdxPlugin(options = {}) {
   const {
     environment = "bun",
-    outDir = ".source",
-    configPath = findConfigFile(),
+    outDir = _Defaults.outDir,
+    configPath = _Defaults.configPath,
     disableMetaFile = false
   } = options;
   return {

package/dist/chunk-4JSFLXXT.js

@@ -0,0 +1,8 @@
+// src/loaders/index.ts
+var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+
+export {
+  metaLoaderGlob,
+  mdxLoaderGlob
+};

package/dist/chunk-5UMZCWKV.js

@@ -0,0 +1,17 @@
+import {
+  createCore
+} from "./chunk-7L2KNF6B.js";
+
+// src/webpack/index.ts
+var core;
+function getCore(options) {
+  return core ??= createCore({
+    environment: "webpack",
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
+}
+
+export {
+  getCore
+};

package/dist/chunk-5YXP7JLN.js

@@ -0,0 +1,138 @@
+// src/runtime/server.ts
+import * as path from "path";
+function fromConfig() {
+  function fileInfo(file, base) {
+    if (file.startsWith("./")) {
+      file = file.slice(2);
+    }
+    return {
+      path: file,
+      fullPath: path.join(base, file)
+    };
+  }
+  function mapDocData(entry) {
+    return {
+      body: entry.default,
+      toc: entry.toc,
+      extractedReferences: entry.extractedReferences,
+      structuredData: entry.structuredData,
+      lastModified: entry.lastModified,
+      _exports: entry
+    };
+  }
+  return {
+    async doc(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            ...mapDocData(data),
+            ...data.frontmatter,
+            ...createDocMethods(fileInfo(k, base), () => data)
+          };
+        })
+      );
+      return out;
+    },
+    async docLazy(_name, base, head, body) {
+      const out = await Promise.all(
+        Object.entries(head).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          const content = body[k];
+          return {
+            ...data,
+            ...createDocMethods(fileInfo(k, base), content),
+            async load() {
+              return mapDocData(await content());
+            }
+          };
+        })
+      );
+      return out;
+    },
+    async meta(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            info: fileInfo(k, base),
+            ...data
+          };
+        })
+      );
+      return out;
+    },
+    async docs(name, base, metaGlob, docGlob) {
+      const entry = {
+        docs: await this.doc(name, base, docGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    },
+    async docsLazy(name, base, metaGlob, docHeadGlob, docBodyGlob) {
+      const entry = {
+        docs: await this.docLazy(name, base, docHeadGlob, docBodyGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toFumadocsSource(pages, metas) {
+  const files = [];
+  for (const entry of pages) {
+    files.push({
+      type: "page",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  for (const entry of metas) {
+    files.push({
+      type: "meta",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  return {
+    files
+  };
+}
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        const fs = await import("fs/promises");
+        return (await fs.readFile(info.fullPath)).toString();
+      }
+      const data = await load();
+      if (typeof data._markdown !== "string")
+        throw new Error(
+          "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+        );
+      return data._markdown;
+    },
+    async getMDAST() {
+      const data = await load();
+      if (!data._mdast)
+        throw new Error(
+          "getMDAST() requires `includeMDAST` to be enabled in your collection config."
+        );
+      return JSON.parse(data._mdast);
+    }
+  };
+}
+
+export {
+  fromConfig,
+  toFumadocsSource
+};

package/dist/{chunk-2E2JCOSO.js → chunk-6NISOLQ6.js}

@@ -1,13 +1,6 @@
 import {
-  buildMDX
-} from "./chunk-3J3WL7WN.js";
-import {
-  getGitTimestamp
-} from "./chunk-VUEZTR2H.js";
-import {
-  mdxLoaderGlob,
-  validate
-} from "./chunk-2AQRQXSO.js";
+  mdxLoaderGlob
+} from "./chunk-4JSFLXXT.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
@@ -36,10 +29,10 @@ function createMdxLoader(configLoader) {
       compiler,
       filePath
     }) {
+      const config = await configLoader.getConfig();
       const value = await getSource();
       const matter = fumaMatter(value);
       const parsed = querySchema.parse(query);
-      const config = await configLoader.getConfig();
       let after;
       if (!isDevelopment && config.global.experimentalBuildCache) {
         const cacheDir = config.global.experimentalBuildCache;
@@ -67,15 +60,10 @@ function createMdxLoader(configLoader) {
           docCollection = collection.docs;
           break;
       }
-      if (docCollection?.schema) {
-        matter.data = await validate(
-          docCollection.schema,
-          matter.data,
-          {
-            source: value,
-            path: filePath
-          },
-          `invalid frontmatter in ${filePath}`
+      if (docCollection) {
+        matter.data = await configLoader.core.transformFrontmatter(
+          { collection: docCollection, filePath, source: value },
+          matter.data
         );
       }
       if (parsed.only === "frontmatter") {
@@ -84,24 +72,16 @@ function createMdxLoader(configLoader) {
           map: null
         };
       }
-      const data = {};
-      if (config.global.lastModifiedTime === "git") {
-        data.lastModified = (await getGitTimestamp(filePath))?.getTime();
-      }
       const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const compiled = await buildMDX(
-        `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
-        "\n".repeat(lineOffset) + matter.content,
-        {
-          development: isDevelopment,
-          ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
-          postprocess: docCollection?.postprocess,
-          data,
-          filePath,
-          frontmatter: matter.data,
-          _compiler: compiler
-        }
-      );
+      const { buildMDX } = await import("./build-mdx-6UAK5FF5.js");
+      const compiled = await buildMDX(configLoader.core, docCollection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
       const out = {
         code: String(compiled.value),
         map: compiled.map
@@ -111,14 +91,6 @@ function createMdxLoader(configLoader) {
     }
   };
 }
-var hashes = /* @__PURE__ */ new WeakMap();
-function getConfigHash(config) {
-  let hash = hashes.get(config);
-  if (hash) return hash;
-  hash = Date.now().toString();
-  hashes.set(config, hash);
-  return hash;
-}
 function generateCacheHash(input) {
   return createHash("md5").update(input).digest("hex");
 }

package/dist/chunk-7L2KNF6B.js

@@ -0,0 +1,180 @@
+import {
+  removeFileCache
+} from "./chunk-PKI7ZDA5.js";
+
+// src/utils/validation.ts
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+    this.title = message;
+    this.issues = issues;
+  }
+  async toStringFormatted() {
+    const picocolors = await import("picocolors");
+    return [
+      picocolors.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => picocolors.redBright(
+          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        )
+      )
+    ].join("\n");
+  }
+};
+async function validate(schema, data, context, errorMessage) {
+  if (typeof schema === "function" && !("~standard" in schema)) {
+    schema = schema(context);
+  }
+  if ("~standard" in schema) {
+    const result = await schema["~standard"].validate(
+      data
+    );
+    if (result.issues) {
+      throw new ValidationError(errorMessage, result.issues);
+    }
+    return result.value;
+  }
+  return data;
+}
+
+// src/core.ts
+import path from "path";
+import fs from "fs/promises";
+var _Defaults = {
+  configPath: "source.config.ts",
+  outDir: ".source"
+};
+async function getPlugins(pluginOptions) {
+  const plugins = [];
+  for await (const option of pluginOptions) {
+    if (!option) continue;
+    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
+    else plugins.push(option);
+  }
+  return plugins;
+}
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins;
+  async function transformMetadata({
+    collection,
+    filePath,
+    source
+  }, data) {
+    if (collection.schema) {
+      data = await validate(
+        collection.schema,
+        data,
+        { path: filePath, source },
+        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
+      );
+    }
+    return data;
+  }
+  const core = {
+    _options: options,
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: /* @__PURE__ */ new Map(),
+    async init({ config: newConfig }) {
+      config = await newConfig;
+      this.cache.clear();
+      plugins = await getPlugins([
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]);
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(pluginContext, config);
+        if (out) config = out;
+      }
+      return this;
+    },
+    getConfig() {
+      return config;
+    },
+    /**
+     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+     */
+    getCompiledConfigPath() {
+      return path.join(options.outDir, "source.config.mjs");
+    },
+    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);
+      }
+    },
+    async emit({ filterPlugin = () => true } = {}) {
+      return (await Promise.all(
+        plugins.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(pluginContext);
+        })
+      )).flat();
+    },
+    async emitAndWrite(emitOptions) {
+      const start = performance.now();
+      const out = await this.emit(emitOptions);
+      await Promise.all(
+        out.map(async (entry) => {
+          const file = path.join(options.outDir, entry.path);
+          await fs.mkdir(path.dirname(file), { recursive: true });
+          await fs.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    },
+    async transformMeta(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.meta?.transform)
+          data = await plugin.meta.transform.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformFrontmatter(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.doc?.frontmatter)
+          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformVFile(options2, file) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      for (const plugin of plugins) {
+        if (plugin.doc?.vfile)
+          file = await plugin.doc.vfile.call(ctx, file) ?? file;
+      }
+      return file;
+    }
+  };
+  const pluginContext = {
+    core,
+    ...options
+  };
+  return core;
+}
+
+export {
+  ValidationError,
+  _Defaults,
+  createCore
+};

package/dist/chunk-E5DJTSIM.js

@@ -0,0 +1,86 @@
+// src/config/preset.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function applyMdxPreset(options = {}) {
+  return async (environment = "bundler") => {
+    if (options.preset === "minimal") return options;
+    const plugins = await import("fumadocs-core/mdx-plugins");
+    const {
+      valueToExport = [],
+      rehypeCodeOptions,
+      remarkImageOptions,
+      remarkHeadingOptions,
+      remarkStructureOptions,
+      remarkCodeTabOptions,
+      remarkNpmOptions,
+      ...mdxOptions
+    } = options;
+    const remarkPlugins = pluginOption(
+      (v) => [
+        plugins.remarkGfm,
+        [
+          plugins.remarkHeading,
+          {
+            generateToc: false,
+            ...remarkHeadingOptions
+          }
+        ],
+        remarkImageOptions !== false && [
+          plugins.remarkImage,
+          {
+            ...remarkImageOptions,
+            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
+          }
+        ],
+        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+          plugins.remarkCodeTab,
+          remarkCodeTabOptions
+        ],
+        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+        ...v,
+        remarkStructureOptions !== false && [
+          plugins.remarkStructure,
+          remarkStructureOptions
+        ],
+        valueToExport.length > 0 && (() => {
+          return (_, file) => {
+            file.data["mdx-export"] ??= [];
+            for (const name of valueToExport) {
+              if (!(name in file.data)) continue;
+              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: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
+  };
+}
+
+export {
+  applyMdxPreset
+};

package/dist/{chunk-K5ZLPEIQ.js → chunk-FBLMK4RS.js}

@@ -53,6 +53,14 @@ function remarkMarkAndUnravel() {
   };
 }
 
+// src/loaders/mdx/mdast-utils.ts
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+
 // src/loaders/mdx/remark-include.ts
 var ElementLikeTypes = [
   "mdxJsxFlowElement",
@@ -76,12 +84,6 @@ function parseElementAttributes(element) {
   }
   return element.attributes ?? {};
 }
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 function parseSpecifier(specifier) {
   const idx = specifier.lastIndexOf("#");
   if (idx === -1) return { file: specifier };
@@ -203,5 +205,6 @@ ${e instanceof Error ? e.message : String(e)}`,
 }
 
 export {
+  flattenNode,
   remarkInclude
 };

package/dist/{chunk-QXHN25N3.js → chunk-OXSRIWQW.js}

@@ -1,16 +1,15 @@
 import {
   buildConfig
-} from "./chunk-2HXTGJBI.js";
+} from "./chunk-ZY6UZ7NH.js";
 
 // src/config/load-from-file.ts
-import * as path from "path";
 import { pathToFileURL } from "url";
-async function compileConfig(configPath, outDir) {
+async function compileConfig(core) {
   const { build } = await import("esbuild");
   const transformed = await build({
-    entryPoints: [{ in: configPath, out: "source.config" }],
+    entryPoints: [{ in: core._options.configPath, out: "source.config" }],
     bundle: true,
-    outdir: outDir,
+    outdir: core._options.outDir,
     target: "node20",
     write: true,
     platform: "node",
@@ -25,9 +24,9 @@ async function compileConfig(configPath, outDir) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, outDir, build = false) {
-  if (build) await compileConfig(configPath, outDir);
-  const url = pathToFileURL(path.resolve(outDir, "source.config.mjs"));
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = pathToFileURL(core.getCompiledConfigPath());
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)