fumadocs-mdx 11.9.1 → 11.10.1

package/dist/node/loader.cjs

@@ -0,0 +1,748 @@
+"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-postprocess.ts
+function remarkPostprocess({
+  injectExports
+}) {
+  return (tree, file) => {
+    let title;
+    const urls = [];
+    (0, import_unist_util_visit.visit)(tree, ["heading", "link"], (node) => {
+      if (node.type === "heading" && node.depth === 1) {
+        title = flattenNode(node);
+      }
+      if (node.type !== "link") return;
+      urls.push({
+        href: node.url
+      });
+      return "skip";
+    });
+    if (title) {
+      file.data.frontmatter ??= {};
+      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
+    }
+    file.data.extractedReferences = urls;
+    for (const name of injectExports) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
+}
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            attributes: [],
+            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_unist_util_visit, import_estree_util_value_to_estree;
+var init_remark_postprocess = __esm({
+  "src/mdx-plugins/remark-postprocess.ts"() {
+    "use strict";
+    import_unist_util_visit = require("unist-util-visit");
+    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,
+  remarkCodeTabOptions,
+  remarkNpmOptions,
+  _withoutBundler = false,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "extractedReferences",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  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
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [
+        remarkPostprocess,
+        { injectExports: mdxExports }
+      ]
+    ],
+    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
+  };
+}
+var plugins;
+var init_mdx_options = __esm({
+  "src/utils/mdx-options.ts"() {
+    "use strict";
+    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
+    init_remark_postprocess();
+  }
+});
+
+// src/node/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  load: () => load2
+});
+module.exports = __toCommonJS(loader_exports);
+
+// src/utils/config.ts
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/config/build.ts
+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" && "type" in v) {
+      if (v.type === "docs") {
+        collections.set(k, v);
+        continue;
+      }
+      if (v.type === "doc" || v.type === "meta") {
+        collections.set(k, v);
+        continue;
+      }
+    }
+    if (k === "default" && v) {
+      globalConfig = v;
+      continue;
+    }
+    throw new Error(
+      `Unknown export "${k}", you can only export collections from source configuration file.`
+    );
+  }
+  const mdxOptionsCache = /* @__PURE__ */ new Map();
+  return {
+    global: globalConfig,
+    collections,
+    async getDefaultMDXOptions(mode = "default") {
+      const cached = mdxOptionsCache.get(mode);
+      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_mdx_options(), mdx_options_exports));
+        if (options?.preset === "minimal") return options;
+        return getDefaultMDXOptions2({
+          ...options,
+          _withoutBundler: mode === "remote"
+        });
+      }
+      const result = uncached();
+      mdxOptionsCache.set(mode, result);
+      return result;
+    }
+  };
+}
+
+// src/utils/config.ts
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+var cache = null;
+async function isZod3() {
+  try {
+    const content = JSON.parse(
+      (await fs.readFile("node_modules/zod/package.json")).toString()
+    );
+    const version = content.version;
+    return typeof version === "string" && version.startsWith("3.");
+  } catch {
+    return false;
+  }
+}
+function createCompatZodPlugin() {
+  return {
+    name: "replace-zod-import",
+    async setup(build) {
+      const usingZod3 = await isZod3();
+      if (!usingZod3) return;
+      console.warn(
+        "[Fumadocs MDX] Noticed Zod v3 in your node_modules, we recommend upgrading to Zod v4 for better compatibility."
+      );
+      build.onResolve({ filter: /^fumadocs-mdx\/config$/ }, () => {
+        return {
+          path: "fumadocs-mdx/config/zod-3",
+          external: true
+        };
+      });
+    }
+  };
+}
+async function compileConfig(configPath, outDir) {
+  const { build } = await import("esbuild");
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins: [createCompatZodPlugin()],
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(configPath, outDir, hash, build = false) {
+  if (cache && cache.hash === hash) {
+    return await cache.config;
+  }
+  if (build) await compileConfig(configPath, outDir);
+  const url = (0, import_node_url.pathToFileURL)(path.resolve(outDir, "source.config.mjs"));
+  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
+    return buildConfig(
+      // every call to `loadConfig` will cause the previous cache to be ignored
+      loaded
+    );
+  });
+  if (hash) cache = { config, hash };
+  return await config;
+}
+async function getConfigHash(configPath) {
+  const stats = await fs.stat(configPath).catch(() => void 0);
+  if (stats) {
+    return stats.mtime.getTime().toString();
+  }
+  throw new Error("Cannot find config file");
+}
+
+// src/utils/fuma-matter.ts
+var import_js_yaml = require("js-yaml");
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = (0, import_js_yaml.load)(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+// src/utils/validation.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+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;
+  }
+  toStringFormatted() {
+    return [
+      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => import_picocolors.default.redBright(
+          `- ${import_picocolors.default.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/utils/git-timestamp.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_tinyexec = require("tinyexec");
+var cache2 = /* @__PURE__ */ new Map();
+async function getGitTimestamp(file) {
+  const cached = cache2.get(file);
+  if (cached) return cached;
+  try {
+    const out = await (0, import_tinyexec.x)(
+      "git",
+      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
+    );
+    const time = new Date(out.stdout);
+    cache2.set(file, time);
+    return time;
+  } catch {
+    return;
+  }
+}
+
+// src/utils/count-lines.ts
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+// src/utils/build-mdx.ts
+var import_mdx = require("@mdx-js/mdx");
+
+// src/mdx-plugins/remark-include.ts
+var import_unified = require("unified");
+var import_unist_util_visit2 = require("unist-util-visit");
+var path3 = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs/promises"), 1);
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+var import_remark_mdx = __toESM(require("remark-mdx"), 1);
+var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+var baseProcessor = (0, import_unified.unified)().use(import_mdx_plugins.remarkHeading);
+function flattenNode2(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode2(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+function parseSpecifier(specifier) {
+  const idx = specifier.lastIndexOf("#");
+  if (idx === -1) return { file: specifier };
+  return {
+    file: specifier.slice(0, idx),
+    section: specifier.slice(idx + 1)
+  };
+}
+function extractSection(root, section) {
+  let nodes;
+  for (const node of root.children) {
+    if (node.type === "mdxJsxFlowElement" && node.name === "section" && node.attributes.some(
+      (attr) => attr.type === "mdxJsxAttribute" && attr.name === "id" && attr.value === section
+    )) {
+      nodes = node.children;
+      break;
+    }
+    if (node.type === "heading" && node.data?.hProperties?.id === section) {
+      nodes = [node];
+      continue;
+    }
+    if (!nodes) continue;
+    if (node.type === "heading") break;
+    nodes.push(node);
+  }
+  if (nodes)
+    return {
+      type: "root",
+      children: nodes
+    };
+}
+function remarkInclude() {
+  const TagName = "include";
+  async function embedContent(file, heading, params, data) {
+    let content;
+    try {
+      content = (await fs2.readFile(file)).toString();
+    } catch (e) {
+      throw new Error(
+        `failed to read file ${file}
+${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+    const ext = path3.extname(file);
+    data._compiler?.addDependency(file);
+    if (params.lang || ext !== ".md" && ext !== ".mdx") {
+      const lang = params.lang ?? ext.slice(1);
+      return {
+        type: "code",
+        lang,
+        meta: params.meta,
+        value: content,
+        data: {}
+      };
+    }
+    const processor = (data._getProcessor ?? getDefaultProcessor)(
+      ext === ".mdx" ? "mdx" : "md"
+    );
+    let parsed = await baseProcessor.run(
+      processor.parse(fumaMatter(content).content)
+    );
+    if (heading) {
+      const extracted = extractSection(parsed, heading);
+      if (!extracted)
+        throw new Error(
+          `Cannot find section ${heading} in ${file}, make sure you have encapsulated the section in a <section id="${heading}"> tag.`
+        );
+      parsed = extracted;
+    }
+    await update(parsed, path3.dirname(file), data);
+    return parsed;
+  }
+  async function update(tree, directory, data) {
+    const queue = [];
+    (0, import_unist_util_visit2.visit)(
+      tree,
+      ["mdxJsxFlowElement", "mdxJsxTextElement"],
+      (_node, _, parent) => {
+        const node = _node;
+        if (node.name !== TagName) return;
+        const params = {};
+        const specifier = flattenNode2(node);
+        if (specifier.length === 0) return "skip";
+        for (const attr of node.attributes) {
+          if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
+            params[attr.name] = attr.value;
+          }
+        }
+        const { file: relativePath, section } = parseSpecifier(specifier);
+        const file = path3.resolve(
+          "cwd" in params ? process.cwd() : directory,
+          relativePath
+        );
+        queue.push(
+          embedContent(file, section, params, data).then((replace) => {
+            Object.assign(
+              parent && parent.type === "paragraph" ? parent : node,
+              replace
+            );
+          })
+        );
+        return "skip";
+      }
+    );
+    await Promise.all(queue);
+  }
+  return async (tree, file) => {
+    await update(tree, path3.dirname(file.path), file.data);
+  };
+}
+function getDefaultProcessor(format) {
+  const mdProcessor = (0, import_unified.unified)().use(import_remark_parse.default);
+  if (format === "md") return mdProcessor;
+  return mdProcessor.use(import_remark_mdx.default);
+}
+
+// src/utils/build-mdx.ts
+var cache3 = /* @__PURE__ */ new Map();
+async function buildMDX(cacheKey, source, options) {
+  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+  function getProcessor(format) {
+    const key = `${cacheKey}:${format}`;
+    let processor = cache3.get(key);
+    if (!processor) {
+      processor = (0, import_mdx.createProcessor)({
+        outputFormat: "program",
+        ...rest,
+        remarkPlugins: [remarkInclude, ...rest.remarkPlugins ?? []],
+        format
+      });
+      cache3.set(key, processor);
+    }
+    return processor;
+  }
+  return getProcessor(
+    options.format ?? filePath.endsWith(".mdx") ? "mdx" : "md"
+  ).process({
+    value: source,
+    path: filePath,
+    data: {
+      ...data,
+      frontmatter,
+      _compiler,
+      _getProcessor: getProcessor
+    }
+  });
+}
+
+// src/loaders/mdx.ts
+var import_zod = require("zod");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var querySchema = import_zod.z.object({
+  only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
+  collection: import_zod.z.string().optional(),
+  hash: import_zod.z.string().describe(
+    "the hash of config, used for revalidation on Turbopack/Webpack."
+  ).optional()
+}).loose();
+var cacheEntry = import_zod.z.object({
+  code: import_zod.z.string(),
+  map: import_zod.z.any().optional(),
+  hash: import_zod.z.string().optional()
+});
+function createMdxLoader(configLoader) {
+  return async ({
+    source: value,
+    development: isDevelopment,
+    query,
+    compiler,
+    filePath
+  }) => {
+    const matter = fumaMatter(value);
+    const parsed = querySchema.parse(query);
+    const loaded = await configLoader.getConfig(parsed.hash);
+    const cacheDir = isDevelopment ? void 0 : loaded.global.experimentalBuildCache;
+    const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+    if (cacheDir) {
+      const cached = await import_promises.default.readFile(import_node_path2.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      if (cached && cached.hash === generateCacheHash(value)) return cached;
+    }
+    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    let schema;
+    let mdxOptions;
+    switch (collection?.type) {
+      case "doc":
+        mdxOptions = collection.mdxOptions;
+        schema = collection.schema;
+        break;
+      case "docs":
+        mdxOptions = collection.docs.mdxOptions;
+        schema = collection.docs.schema;
+        break;
+    }
+    if (schema) {
+      matter.data = await validate(
+        schema,
+        matter.data,
+        {
+          source: value,
+          path: filePath
+        },
+        `invalid frontmatter in ${filePath}`
+      );
+    }
+    if (parsed.only === "frontmatter") {
+      return {
+        code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+        map: null
+      };
+    }
+    const data = {};
+    if (loaded.global.lastModifiedTime === "git") {
+      data.lastModified = (await getGitTimestamp(filePath))?.getTime();
+    }
+    const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+    const compiled = await buildMDX(
+      `${parsed.hash ?? ""}:${parsed.collection ?? "global"}`,
+      "\n".repeat(lineOffset) + matter.content,
+      {
+        development: isDevelopment,
+        ...mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        data,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler
+      }
+    );
+    const out = {
+      code: String(compiled.value),
+      map: compiled.map
+    };
+    if (cacheDir) {
+      await import_promises.default.mkdir(cacheDir, { recursive: true });
+      await import_promises.default.writeFile(
+        import_node_path2.default.join(cacheDir, cacheKey),
+        JSON.stringify({
+          ...out,
+          hash: generateCacheHash(value)
+        })
+      );
+    }
+    return out;
+  };
+}
+function generateCacheHash(input) {
+  return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
+}
+
+// src/loaders/config-loader.ts
+function dynamicConfig(configPath, outDir) {
+  return {
+    async getConfig(hash) {
+      return loadConfig(
+        configPath,
+        outDir,
+        hash ?? await getConfigHash(configPath)
+      );
+    }
+  };
+}
+
+// src/loaders/adapter.ts
+var import_node_url2 = require("url");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_querystring = require("querystring");
+var import_node_path3 = __toESM(require("path"), 1);
+function toNode(loader, filterByPath) {
+  return async (url, _context, nextLoad) => {
+    if (!url.startsWith("file:///")) return nextLoad(url);
+    const parsedUrl = new URL(url);
+    const filePath = (0, import_node_url2.fileURLToPath)(parsedUrl);
+    if (filterByPath(filePath)) {
+      const source = (await import_promises2.default.readFile(filePath)).toString();
+      const result = await loader({
+        filePath,
+        query: Object.fromEntries(parsedUrl.searchParams.entries()),
+        source,
+        development: false,
+        compiler: {
+          addDependency() {
+          }
+        }
+      });
+      return {
+        source: result.code,
+        format: "module",
+        shortCircuit: true
+      };
+    }
+    return nextLoad(url);
+  };
+}
+
+// src/node/loader.ts
+var load2 = toNode(
+  createMdxLoader(dynamicConfig(findConfigFile(), ".source")),
+  (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  load
+});