fumadocs-mdx 11.2.2 → 11.3.0

package/dist/loader-mdx.js

@@ -3,14 +3,11 @@ import {
 } from "./chunk-GUHWD47S.js";
 import {
   getConfigHash,
-  getManifestEntryPath,
   loadConfigCached
-} from "./chunk-2KEQHW7J.js";
-import "./chunk-MKWJLEE7.js";
+} from "./chunk-2ZPSMAUV.js";
 
 // src/loader-mdx.ts
 import * as path2 from "node:path";
-import * as fs2 from "node:fs/promises";
 import { parse } from "node:querystring";
 import grayMatter from "gray-matter";
 
@@ -54,7 +51,7 @@ function buildMDX(group, configHash, source, options = {}) {
 }
 
 // src/utils/format-error.ts
-function formatError(file, error) {
+function formatError(message, error) {
   const lines = [];
   function walk(key, { _errors, ...rest }, padStart = 0) {
     if (key !== void 0 || _errors.length > 0) {
@@ -68,7 +65,7 @@ function formatError(file, error) {
     }
   }
   walk(void 0, error.format());
-  return [`in ${file}:`, ...lines].join("\n");
+  return [message, ...lines].join("\n");
 }
 
 // src/utils/git-timestamp.ts
@@ -124,7 +121,7 @@ async function loader(source, callback) {
   if (collection && collection.type !== "doc") {
     collection = void 0;
   }
-  const mdxOptions = collection?.mdxOptions ?? config.defaultMdxOptions;
+  const mdxOptions = collection?.mdxOptions ?? await config.getDefaultMDXOptions();
   let frontmatter = matter.data;
   if (collection?.schema) {
     let schema = collection.schema;
@@ -145,7 +142,11 @@ async function loader(source, callback) {
     }
     const result = await schema.safeParseAsync(frontmatter);
     if (result.error) {
-      callback(new Error(formatError(filePath, result.error)));
+      callback(
+        new Error(
+          formatError(`invalid frontmatter in ${filePath}:`, result.error)
+        )
+      );
       return;
     }
     frontmatter = result.data;
@@ -170,16 +171,6 @@ async function loader(source, callback) {
       }
     );
     callback(void 0, String(file.value), file.map ?? void 0);
-    if (config.global?.generateManifest) {
-      await fs2.mkdir(".next/cache/fumadocs", { recursive: true });
-      await fs2.writeFile(
-        getManifestEntryPath(filePath),
-        JSON.stringify({
-          path: filePath,
-          data: file.data
-        })
-      );
-    }
   } catch (error) {
     if (!(error instanceof Error)) throw error;
     const fpath = path2.relative(context, filePath);

package/dist/mdx-options-L5C3NQRY.js

@@ -0,0 +1,6 @@
+import {
+  getDefaultMDXOptions
+} from "./chunk-6LEQ23AC.js";
+export {
+  getDefaultMDXOptions
+};

package/dist/next/index.cjs

@@ -0,0 +1,556 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mdx-plugins/remark-exports.ts
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: (0, import_estree_util_value_to_estree.valueToEstree)(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+var import_estree_util_value_to_estree;
+var init_remark_exports = __esm({
+  "src/mdx-plugins/remark-exports.ts"() {
+    "use strict";
+    import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+  }
+});
+
+// src/utils/mdx-options.ts
+var mdx_options_exports = {};
+__export(mdx_options_exports, {
+  getDefaultMDXOptions: () => getDefaultMDXOptions
+});
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      import_mdx_plugins.remarkGfm,
+      [
+        import_mdx_plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [import_mdx_plugins.remarkImage, remarkImageOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        import_mdx_plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [import_mdx_plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      [import_mdx_plugins.rehypeToc]
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+var import_mdx_plugins;
+var init_mdx_options = __esm({
+  "src/utils/mdx-options.ts"() {
+    "use strict";
+    import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+    init_remark_exports();
+  }
+});
+
+// src/map/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  watcher: () => watcher
+});
+function watcher(configPath, config) {
+  const deps = [configPath];
+  for (const collection of config.collections.values()) {
+    if (Array.isArray(collection.dir)) deps.push(...collection.dir);
+    else deps.push(collection.dir);
+  }
+  return (0, import_chokidar.watch)(deps, {
+    ignoreInitial: true,
+    persistent: true
+  });
+}
+var import_chokidar;
+var init_watcher = __esm({
+  "src/map/watcher.ts"() {
+    "use strict";
+    import_chokidar = require("chokidar");
+  }
+});
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall,
+  start: () => start
+});
+module.exports = __toCommonJS(next_exports);
+
+// src/next/create.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/config/load.ts
+var path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+async function loadConfig(configPath) {
+  const { build } = await import("esbuild");
+  const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: ".source",
+    target: "node18",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+  const loaded = await import(`${url.href}?hash=${Date.now().toString()}`);
+  const [err, config] = buildConfig(
+    // every call to `loadConfig` will cause the previous cache to be ignored
+    loaded
+  );
+  if (err !== null) throw new Error(err);
+  return config;
+}
+function buildConfig(config) {
+  const collections = /* @__PURE__ */ new Map();
+  let globalConfig;
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "_doc" in v && v._doc === "collections") {
+      collections.set(
+        k,
+        v
+      );
+      continue;
+    }
+    if (k === "default") {
+      globalConfig = v;
+      continue;
+    }
+    return [
+      `Unknown export "${k}", you can only export collections from source configuration file.`,
+      null
+    ];
+  }
+  let cachedMdxOptions;
+  return [
+    null,
+    {
+      global: globalConfig,
+      collections,
+      async getDefaultMDXOptions() {
+        if (cachedMdxOptions) return cachedMdxOptions;
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
+        const mdxOptions = globalConfig?.mdxOptions ?? {};
+        if (typeof mdxOptions === "function") {
+          cachedMdxOptions = getDefaultMDXOptions2(await mdxOptions());
+        } else {
+          cachedMdxOptions = getDefaultMDXOptions2(mdxOptions);
+        }
+        return cachedMdxOptions;
+      },
+      _runtime: {
+        files: /* @__PURE__ */ new Map()
+      }
+    }
+  ];
+}
+
+// src/map/index.ts
+var path3 = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var import_promises = require("fs/promises");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/config/cached.ts
+var import_node_crypto = require("crypto");
+var fs = __toESM(require("fs"), 1);
+var cache = /* @__PURE__ */ new Map();
+async function loadConfigCached(configPath, hash) {
+  const cached = cache.get(configPath);
+  if (cached && cached.hash === hash) {
+    return await cached.config;
+  }
+  const config = loadConfig(configPath);
+  cache.set(configPath, { config, hash });
+  return await config;
+}
+async function getConfigHash(configPath) {
+  const hash = (0, import_node_crypto.createHash)("md5");
+  const rs = fs.createReadStream(configPath);
+  for await (const chunk of rs) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+
+// src/map/generate.ts
+var path2 = __toESM(require("path"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+
+// src/utils/get-type-from-path.ts
+var import_node_path = require("path");
+var docTypes = [".mdx", ".md"];
+var metaTypes = [".json", ".yaml"];
+function getTypeFromPath(path6) {
+  const ext = (0, import_node_path.extname)(path6);
+  if (docTypes.includes(ext)) return "doc";
+  if (metaTypes.includes(ext)) return "meta";
+}
+
+// src/map/generate.ts
+async function generateJS(configPath, config, outputPath, configHash, getFrontmatter) {
+  const outDir2 = path2.dirname(outputPath);
+  const imports = [
+    {
+      type: "named",
+      names: ["toRuntime", "toRuntimeAsync"],
+      specifier: "fumadocs-mdx"
+    }
+  ];
+  const importedCollections = /* @__PURE__ */ new Set();
+  async function generateEntry(file, collectionName, collection, importId) {
+    if (collection.type === "doc" && collection.async) {
+      const importPath = `${toImportPath(file.absolutePath, outDir2)}?hash=${configHash}&collection=${collectionName}`;
+      const frontmatter = await getFrontmatter(file.absolutePath);
+      return `toRuntimeAsync(${JSON.stringify(frontmatter)}, () => import(${JSON.stringify(importPath)}), ${JSON.stringify(file)})`;
+    }
+    imports.push({
+      type: "namespace",
+      name: importId,
+      specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${collectionName}&hash=${configHash}`
+    });
+    return `toRuntime("${collection.type}", ${importId}, ${JSON.stringify(file)})`;
+  }
+  config._runtime.files.clear();
+  const entries = Array.from(config.collections.entries());
+  const declares = entries.map(async ([k, collection]) => {
+    const files = await getCollectionFiles(collection);
+    const items = files.map(async (file, i) => {
+      config._runtime.files.set(file.absolutePath, k);
+      return generateEntry(file, k, collection, `${k}_${i}`);
+    });
+    const resolvedItems = await Promise.all(items);
+    if (collection.transform) {
+      if (config.global) importedCollections.add("default");
+      importedCollections.add(k);
+    }
+    return collection.transform ? `export const ${k} = await Promise.all([${resolvedItems.join(", ")}].map(v => c_${k}.transform(v, ${config.global ? "c_default" : "undefined"})));` : `export const ${k} = [${resolvedItems.join(", ")}];`;
+  });
+  const resolvedDeclares = await Promise.all(declares);
+  if (importedCollections.size > 0) {
+    imports.push({
+      type: "named",
+      names: Array.from(importedCollections.values()).sort().map((v) => [v, `c_${v}`]),
+      specifier: toImportPath(configPath, outDir2)
+    });
+  }
+  return [...imports.map(getImportCode), ...resolvedDeclares].join("\n");
+}
+async function getCollectionFiles(collection) {
+  const files = /* @__PURE__ */ new Map();
+  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+  await Promise.all(
+    dirs.map(async (dir) => {
+      const result = await (0, import_fast_glob.default)(collection.files ?? "**/*", {
+        cwd: path2.resolve(dir),
+        absolute: true
+      });
+      for (const item of result) {
+        if (getTypeFromPath(item) !== collection.type) continue;
+        files.set(item, {
+          path: path2.relative(dir, item),
+          absolutePath: item
+        });
+      }
+    })
+  );
+  return Array.from(files.values());
+}
+function getImportCode(info) {
+  const specifier = JSON.stringify(info.specifier);
+  if (info.type === "default") return `import ${info.name} from ${specifier}`;
+  if (info.type === "namespace")
+    return `import * as ${info.name} from ${specifier}`;
+  if (info.type === "named") {
+    const names = info.names.map(
+      (name) => Array.isArray(name) ? `${name[0]} as ${name[1]}` : name
+    );
+    return `import { ${names.join(", ")} } from ${specifier}`;
+  }
+  return `import ${specifier}`;
+}
+function toImportPath(file, dir) {
+  let importPath = path2.relative(dir, file);
+  if (!path2.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = `./${importPath}`;
+  }
+  return importPath.replaceAll(path2.sep, "/");
+}
+function generateTypes(configPath, config, outputPath) {
+  const importPath = JSON.stringify(
+    toImportPath(configPath, path2.dirname(outputPath))
+  );
+  const lines = [
+    'import type { GetOutput } from "fumadocs-mdx/config"'
+  ];
+  for (const name of config.collections.keys()) {
+    lines.push(
+      `export declare const ${name}: GetOutput<typeof import(${importPath}).${name}>`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/map/index.ts
+async function start(dev, configPath, outDir2) {
+  let configHash = await getConfigHash(configPath);
+  let config = await loadConfigCached(configPath, configHash);
+  const jsOut = path3.resolve(outDir2, `index.js`);
+  const typeOut = path3.resolve(outDir2, `index.d.ts`);
+  const frontmatterCache = /* @__PURE__ */ new Map();
+  let hookUpdate = false;
+  const readFrontmatter = async (file) => {
+    const cached = frontmatterCache.get(file);
+    if (cached) return cached;
+    hookUpdate = true;
+    return (0, import_gray_matter.default)({
+      content: await (0, import_promises.readFile)(file).then((res) => res.toString())
+    }).data;
+  };
+  fs2.mkdirSync(outDir2, { recursive: true });
+  fs2.writeFileSync(
+    jsOut,
+    await generateJS(configPath, config, jsOut, configHash, readFrontmatter)
+  );
+  fs2.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  console.log("[MDX] initialized map file");
+  if (dev) {
+    const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
+    const instance = watcher2(configPath, config);
+    instance.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    instance.on("all", (event, file) => {
+      if (typeof file !== "string") return;
+      const onUpdate = async () => {
+        const isConfigFile = path3.resolve(file) === configPath;
+        if (isConfigFile) {
+          configHash = await getConfigHash(configPath);
+          config = await loadConfigCached(configPath, configHash);
+          await (0, import_promises.writeFile)(typeOut, generateTypes(configPath, config, typeOut));
+          console.log("[MDX] Updated map types");
+        }
+        if (isConfigFile || event !== "change" || hookUpdate) {
+          if (event === "change") frontmatterCache.delete(file);
+          await (0, import_promises.writeFile)(
+            jsOut,
+            await generateJS(
+              configPath,
+              config,
+              jsOut,
+              configHash,
+              readFrontmatter
+            )
+          );
+          console.log("[MDX] Updated map file");
+        }
+      };
+      void onUpdate();
+    });
+    process.on("exit", () => {
+      console.log("[MDX] closing dev server");
+      void instance.close();
+    });
+  }
+}
+
+// src/next/create.ts
+var outDir = import_node_path2.default.resolve(".source");
+var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
+function createMDX({
+  configPath = findConfigFile()
+} = {}) {
+  const isDev = process.argv.includes("dev");
+  const isBuild = process.argv.includes("build");
+  if ((isDev || isBuild) && process.env._FUMADOCS_MDX !== "1") {
+    process.env._FUMADOCS_MDX = "1";
+    void start(isDev, configPath, outDir);
+  }
+  return (nextConfig = {}) => {
+    const mdxLoaderOptions = {
+      _ctx: {
+        configPath
+      }
+    };
+    return {
+      ...nextConfig,
+      experimental: {
+        ...nextConfig.experimental,
+        turbo: {
+          ...nextConfig.experimental?.turbo,
+          rules: {
+            ...nextConfig.experimental?.turbo?.rules,
+            // @ts-expect-error -- safe types
+            "*.{md,mdx}": {
+              loaders: [
+                {
+                  loader: "fumadocs-mdx/loader-mdx",
+                  options: mdxLoaderOptions
+                }
+              ],
+              as: "*.js"
+            }
+          }
+        }
+      },
+      pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
+      webpack: (config, options) => {
+        config.resolve ||= {};
+        config.module ||= {};
+        config.module.rules ||= [];
+        config.module.rules.push({
+          test: /\.mdx?$/,
+          use: [
+            options.defaultLoaders.babel,
+            {
+              loader: "fumadocs-mdx/loader-mdx",
+              options: mdxLoaderOptions
+            }
+          ]
+        });
+        config.plugins ||= [];
+        return nextConfig.webpack?.(config, options) ?? config;
+      }
+    };
+  };
+}
+
+// src/postinstall.ts
+var path5 = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs"), 1);
+async function postInstall(configPath = findConfigFile()) {
+  const typeOut = path5.resolve(".source/index.d.ts");
+  const config = await loadConfig(configPath);
+  fs3.mkdirSync(path5.dirname(typeOut), { recursive: true });
+  fs3.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  console.log("[MDX] types generated");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMDX,
+  postInstall,
+  start
+});

package/dist/next/index.d.cts

@@ -0,0 +1,21 @@
+import { NextConfig } from 'next';
+
+/**
+ * Start a MDX server that builds index and manifest files.
+ *
+ * In development mode, it starts a file watcher to auto-update output as your input changes.
+ */
+declare function start(dev: boolean, configPath: string, outDir: string): Promise<void>;
+
+interface CreateMDXOptions {
+    /**
+     * Path to source configuration file
+     */
+    configPath?: string;
+}
+
+declare function createMDX({ configPath, }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
+
+declare function postInstall(configPath?: string): Promise<void>;
+
+export { type CreateMDXOptions, createMDX, postInstall, start };