fumadocs-mdx 13.0.7 → 14.0.0

package/dist/webpack/meta.cjs

@@ -30,11 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/loaders/mdx/preset.ts
-var preset_exports = {};
-__export(preset_exports, {
-  getDefaultMDXOptions: () => getDefaultMDXOptions
-});
+// src/config/preset.ts
 function pluginOption(def, options = []) {
   const list = def(Array.isArray(options) ? options : []).filter(
     Boolean
@@ -44,76 +40,81 @@ function pluginOption(def, options = []) {
   }
   return list;
 }
-function getDefaultMDXOptions({
-  valueToExport = [],
-  rehypeCodeOptions,
-  remarkImageOptions,
-  remarkHeadingOptions,
-  remarkStructureOptions,
-  remarkCodeTabOptions,
-  remarkNpmOptions,
-  _withoutBundler = false,
-  ...mdxOptions
-}) {
-  const remarkPlugins = pluginOption(
-    (v) => [
-      plugins.remarkGfm,
-      [
-        plugins.remarkHeading,
-        {
-          generateToc: false,
-          ...remarkHeadingOptions
-        }
-      ],
-      remarkImageOptions !== false && [
-        plugins.remarkImage,
-        {
-          ...remarkImageOptions,
-          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
-        }
-      ],
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
-        plugins.remarkCodeTab,
-        remarkCodeTabOptions
+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]
+              });
+            }
+          };
+        })
       ],
-      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
-      ...v,
-      remarkStructureOptions !== false && [
-        plugins.remarkStructure,
-        remarkStructureOptions
+      mdxOptions.remarkPlugins
+    );
+    const rehypePlugins = pluginOption(
+      (v) => [
+        rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+        ...v,
+        plugins.rehypeToc
       ],
-      () => {
-        return (_, file) => {
-          file.data["mdx-export"] ??= [];
-          for (const name of valueToExport) {
-            if (name in file.data)
-              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: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
-    remarkPlugins,
-    rehypePlugins
+      mdxOptions.rehypePlugins
+    );
+    return {
+      ...mdxOptions,
+      outputFormat: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
   };
 }
-var plugins;
 var init_preset = __esm({
-  "src/loaders/mdx/preset.ts"() {
+  "src/config/preset.ts"() {
     "use strict";
-    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
   }
 });
 
@@ -124,7 +125,10 @@ function buildCollection(name, config) {
       ...config,
       name,
       meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs)
+      docs: buildPrimitiveCollection(name, config.docs),
+      hasFile(filePath) {
+        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
+      }
     };
   }
   return buildPrimitiveCollection(name, config);
@@ -178,11 +182,6 @@ function buildConfig(config) {
       `Unknown export "${k}", you can only export collections from source configuration file.`
     );
   }
-  if (loaded.collections) {
-    for (const [k, v] of Object.entries(loaded.collections)) {
-      collections.set(k, buildCollection(k, v));
-    }
-  }
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
     global: loaded,
@@ -190,21 +189,22 @@ function buildConfig(config) {
     getCollection(name) {
       return collections.get(name);
     },
-    async getDefaultMDXOptions(mode = "default") {
-      const cached = mdxOptionsCache.get(mode);
+    getMDXOptions(collection, environment = "bundler") {
+      const key = collection ? `${environment}:${collection.name}` : environment;
+      const cached = mdxOptionsCache.get(key);
       if (cached) return cached;
-      const input = this.global.mdxOptions;
-      async function uncached() {
-        const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
-        if (options?.preset === "minimal") return options;
-        return getDefaultMDXOptions2({
-          ...options,
-          _withoutBundler: mode === "remote"
-        });
+      let result;
+      if (collection?.mdxOptions) {
+        const optionsFn = collection.mdxOptions;
+        result = typeof optionsFn === "function" ? optionsFn(environment) : optionsFn;
+      } else {
+        result = (async () => {
+          const optionsFn = this.global.mdxOptions;
+          const options = typeof optionsFn === "function" ? await optionsFn() : optionsFn;
+          return applyMdxPreset(options)(environment);
+        })();
       }
-      const result = uncached();
-      mdxOptionsCache.set(mode, result);
+      mdxOptionsCache.set(key, result);
       return result;
     }
   };
@@ -214,6 +214,7 @@ var init_build = __esm({
   "src/config/build.ts"() {
     "use strict";
     import_picomatch = __toESM(require("picomatch"), 1);
+    init_preset();
     SupportedFormats = {
       doc: ["mdx", "md"],
       meta: ["json", "yaml"]
@@ -226,12 +227,12 @@ var load_from_file_exports = {};
 __export(load_from_file_exports, {
   loadConfig: () => loadConfig
 });
-async function compileConfig(configPath, outDir) {
+async function compileConfig(core2) {
   const { build } = await import("esbuild");
   const transformed = await build({
-    entryPoints: [{ in: configPath, out: "source.config" }],
+    entryPoints: [{ in: core2._options.configPath, out: "source.config" }],
     bundle: true,
-    outdir: outDir,
+    outdir: core2._options.outDir,
     target: "node20",
     write: true,
     platform: "node",
@@ -246,20 +247,19 @@ 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 = (0, import_node_url2.pathToFileURL)(path3.resolve(outDir, "source.config.mjs"));
+async function loadConfig(core2, build = false) {
+  if (build) await compileConfig(core2);
+  const url = (0, import_node_url2.pathToFileURL)(core2.getCompiledConfigPath());
   url.searchParams.set("hash", Date.now().toString());
   const config = import(url.href).then(
     (loaded) => buildConfig(loaded)
   );
   return await config;
 }
-var path3, import_node_url2;
+var import_node_url2;
 var init_load_from_file = __esm({
   "src/config/load-from-file.ts"() {
     "use strict";
-    path3 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     init_build();
   }
@@ -278,7 +278,6 @@ var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
 
 // src/utils/validation.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
 var ValidationError = class extends Error {
   constructor(message, issues) {
     super(
@@ -288,12 +287,13 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
     this.title = message;
     this.issues = issues;
   }
-  toStringFormatted() {
+  async toStringFormatted() {
+    const picocolors = await import("picocolors");
     return [
-      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      picocolors.bold(`[MDX] ${this.title}:`),
       ...this.issues.map(
-        (issue) => import_picocolors.default.redBright(
-          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        (issue) => picocolors.redBright(
+          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
         )
       )
     ].join("\n");
@@ -317,6 +317,7 @@ async function validate(schema, data, context, errorMessage) {
 
 // src/loaders/adapter.ts
 var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = require("fs");
 function toWebpack(loader2) {
   return async function(source, callback) {
     try {
@@ -336,7 +337,7 @@ function toWebpack(loader2) {
       }
     } catch (error) {
       if (error instanceof ValidationError) {
-        return callback(new Error(error.toStringFormatted()));
+        return callback(new Error(await error.toStringFormatted()));
       }
       if (!(error instanceof Error)) throw error;
       const fpath = import_node_path.default.relative(this.context, this.resourcePath);
@@ -346,99 +347,30 @@ function toWebpack(loader2) {
   };
 }
 
-// src/core.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_promises2 = __toESM(require("fs/promises"), 1);
-function createCore(options, defaultPlugins = []) {
-  let config;
-  let plugins2;
-  return {
-    _options: options,
-    getPluginContext() {
-      return {
-        core: this,
-        ...options
-      };
-    },
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      plugins2 = [];
-      for await (const option of [
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
-      ]) {
-        if (!option) continue;
-        if (Array.isArray(option)) plugins2.push(...option);
-        else plugins2.push(option);
-      }
-      for (const plugin of plugins2) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
-        if (out) config = out;
-      }
-      return this;
-    },
-    getConfig() {
-      return config;
-    },
-    async initServer(server) {
-      for (const plugin of plugins2) {
-        await plugin.configureServer?.call(this.getPluginContext(), server);
-      }
-    },
-    async emitAndWrite({
-      filterPlugin = () => true
-    } = {}) {
-      const start = performance.now();
-      const out = await Promise.all(
-        plugins2.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(this.getPluginContext());
-        })
-      );
-      await Promise.all(
-        out.flat().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);
-        })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
-    }
-  };
-}
-
 // src/loaders/config.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 function createStandaloneConfigLoader({
-  core,
+  core: core2,
   buildConfig: buildConfig2,
   mode
 }) {
   let loaded;
   async function getConfigHash() {
     if (mode === "production") return "static";
-    const stats = await import_promises3.default.stat(core._options.configPath).catch(() => {
+    const stats = await import_promises2.default.stat(core2._options.configPath).catch(() => {
       throw new Error("Cannot find config file");
     });
     return stats.mtime.getTime().toString();
   }
   async function newConfig() {
     const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
-    await core.init({
-      config: loadConfig2(
-        core._options.configPath,
-        core._options.outDir,
-        buildConfig2
-      )
+    await core2.init({
+      config: loadConfig2(core2, buildConfig2)
     });
-    return core.getConfig();
+    return core2.getConfig();
   }
   return {
+    core: core2,
     async getConfig() {
       const hash = await getConfigHash();
       if (loaded && loaded.hash === hash) return loaded.config;
@@ -462,91 +394,253 @@ var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
 var querySchema = import_zod.z.object({
   collection: import_zod.z.string().optional()
 }).loose();
-function createMetaLoader(configLoader, resolve2 = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve2;
-  function stringifyOutput(isJson, data) {
-    if (isJson) {
-      return resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`;
-    } else {
-      return resolveYaml === "yaml" ? (0, import_js_yaml.dump)(data) : `export default ${JSON.stringify(data)}`;
+function createMetaLoader(configLoader, resolve = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
+  function parse2(filePath, source) {
+    try {
+      if (filePath.endsWith(".json")) return JSON.parse(source);
+      if (filePath.endsWith(".yaml")) return (0, import_js_yaml.load)(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
     }
+    throw new Error("Unknown file type " + filePath);
   }
-  return {
-    test: metaLoaderGlob,
-    async load({ filePath, query, getSource }) {
-      const parsed = querySchema.parse(query);
-      const collection = parsed.collection ? (await configLoader.getConfig()).getCollection(parsed.collection) : void 0;
-      if (!collection) return null;
-      const isJson = filePath.endsWith(".json");
-      const source = await getSource();
-      let data;
-      try {
-        data = isJson ? JSON.parse(source) : (0, import_js_yaml.load)(source);
-      } catch (e) {
-        throw new Error(`invalid data in ${filePath}`, { cause: e });
-      }
-      let schema;
+  function onMeta(source, { filePath, query }) {
+    const parsed = querySchema.safeParse(query);
+    if (!parsed.success || !parsed.data.collection) return null;
+    const collectionName = parsed.data.collection;
+    return async () => {
+      const config = await configLoader.getConfig();
+      const collection = config.getCollection(collectionName);
+      let metaCollection;
       switch (collection?.type) {
         case "meta":
-          schema = collection.schema;
+          metaCollection = collection;
           break;
         case "docs":
-          schema = collection.meta.schema;
+          metaCollection = collection.meta;
           break;
       }
-      if (schema) {
-        data = await validate(
-          schema,
-          data,
-          { path: filePath, source },
-          `invalid data in ${filePath}`
-        );
+      const data = parse2(filePath, source);
+      if (!metaCollection) return data;
+      return configLoader.core.transformMeta(
+        {
+          collection: metaCollection,
+          filePath,
+          source
+        },
+        data
+      );
+    };
+  }
+  return {
+    test: metaLoaderGlob,
+    async load(input) {
+      const result = onMeta(await input.getSource(), input);
+      if (result === null) return null;
+      const data = await result();
+      if (input.filePath.endsWith(".json")) {
+        return {
+          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
+        };
+      } else {
+        return {
+          code: resolveYaml === "yaml" ? (0, import_js_yaml.dump)(data) : `export default ${JSON.stringify(data)}`
+        };
       }
-      return {
-        code: stringifyOutput(isJson, data)
-      };
     },
     bun: {
-      async fallback({ getSource, filePath }) {
-        const source = await getSource();
-        const isJson = filePath.endsWith(".json");
-        let data;
-        try {
-          data = isJson ? JSON.parse(source) : (0, import_js_yaml.load)(source);
-        } catch (e) {
-          throw new Error(`invalid data in ${filePath}`, { cause: e });
-        }
-        return {
+      load(source, input) {
+        const result = onMeta(source, input);
+        if (result === null)
+          return {
+            loader: "object",
+            exports: parse2(input.filePath, source)
+          };
+        return result().then((data) => ({
           loader: "object",
-          exports: data
-        };
+          exports: { default: data }
+        }));
+      }
+    }
+  };
+}
+
+// src/core.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+
+// src/utils/codegen/cache.ts
+var import_lru_cache = require("lru-cache");
+var import_promises3 = __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/core.ts
+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 core2 = {
+    _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 import_node_path3.default.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 = import_node_path3.default.join(options.outDir, entry.path);
+          await import_promises4.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+          await import_promises4.default.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: core2,
+    ...options
+  };
+  return core2;
+}
+
+// src/webpack/index.ts
+var core;
+function getCore(options) {
+  return core ??= createCore({
+    environment: "webpack",
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
 }
 
 // src/webpack/meta.ts
 var instance;
 async function loader(source, callback) {
-  const { isDev, outDir, configPath } = this.getOptions();
+  const options = this.getOptions();
   this.cacheable(true);
-  this.addDependency(configPath);
+  this.addDependency(options.compiledConfigPath);
   if (!instance) {
-    const core = createCore({
-      environment: "webpack",
-      outDir,
-      configPath
-    });
     instance = toWebpack(
       createMetaLoader(
         createStandaloneConfigLoader({
-          core,
+          core: getCore(options),
           buildConfig: false,
-          mode: isDev ? "dev" : "production"
+          mode: options.isDev ? "dev" : "production"
         }),
         {
           json: "json",
-          yaml: "yaml"
+          yaml: "js"
         }
       )
     );