fumadocs-mdx 11.6.0 → 13.0.1

package/dist/chunk-K5ZLPEIQ.js

@@ -0,0 +1,207 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/remark-include.ts
+import { unified } from "unified";
+import { visit as visit2 } from "unist-util-visit";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { remarkHeading } from "fumadocs-core/mdx-plugins";
+
+// src/loaders/mdx/remark-unravel.ts
+import { visit } from "unist-util-visit";
+function remarkMarkAndUnravel() {
+  return (tree) => {
+    visit(tree, function(node, index, parent) {
+      let offset = -1;
+      let all = true;
+      let oneOrMore = false;
+      if (parent && typeof index === "number" && node.type === "paragraph") {
+        const children = node.children;
+        while (++offset < children.length) {
+          const child = children[offset];
+          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
+            oneOrMore = true;
+          } else if (child.type === "text" && child.value.trim().length === 0) {
+          } else {
+            all = false;
+            break;
+          }
+        }
+        if (all && oneOrMore) {
+          offset = -1;
+          const newChildren = [];
+          while (++offset < children.length) {
+            const child = children[offset];
+            if (child.type === "mdxJsxTextElement") {
+              child.type = "mdxJsxFlowElement";
+            }
+            if (child.type === "mdxTextExpression") {
+              child.type = "mdxFlowExpression";
+            }
+            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
+            } else {
+              newChildren.push(child);
+            }
+          }
+          parent.children.splice(index, 1, ...newChildren);
+          return index;
+        }
+      }
+    });
+  };
+}
+
+// src/loaders/mdx/remark-include.ts
+var ElementLikeTypes = [
+  "mdxJsxFlowElement",
+  "mdxJsxTextElement",
+  "containerDirective",
+  "textDirective",
+  "leafDirective"
+];
+function isElementLike(node) {
+  return ElementLikeTypes.includes(node.type);
+}
+function parseElementAttributes(element) {
+  if (Array.isArray(element.attributes)) {
+    const attributes = {};
+    for (const attr of element.attributes) {
+      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
+        attributes[attr.name] = attr.value;
+      }
+    }
+    return attributes;
+  }
+  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 };
+  return {
+    file: specifier.slice(0, idx),
+    section: specifier.slice(idx + 1)
+  };
+}
+function extractSection(root, section) {
+  let nodes;
+  let capturingHeadingContent = false;
+  visit2(root, (node) => {
+    if (node.type === "heading") {
+      if (capturingHeadingContent) {
+        return false;
+      }
+      if (node.data?.hProperties?.id === section) {
+        capturingHeadingContent = true;
+        nodes = [node];
+        return "skip";
+      }
+      return;
+    }
+    if (capturingHeadingContent) {
+      nodes?.push(node);
+      return "skip";
+    }
+    if (isElementLike(node) && node.name === "section") {
+      const attributes = parseElementAttributes(node);
+      if (attributes.id === section) {
+        nodes = node.children;
+        return false;
+      }
+    }
+  });
+  if (nodes)
+    return {
+      type: "root",
+      children: nodes
+    };
+}
+function remarkInclude() {
+  const TagName = "include";
+  const embedContent = async (file, heading, params, data) => {
+    let content;
+    try {
+      content = (await fs.readFile(file)).toString();
+    } catch (e) {
+      throw new Error(
+        `failed to read file ${file}
+${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+    const ext = path.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 parser = data._getProcessor ? data._getProcessor(ext === ".mdx" ? "mdx" : "md") : this;
+    const parsed = fumaMatter(content);
+    let mdast = parser.parse({
+      path: file,
+      value: parsed.content,
+      data: { frontmatter: parsed.data }
+    });
+    const baseProcessor = unified().use(remarkMarkAndUnravel);
+    if (heading) {
+      const extracted = extractSection(
+        await baseProcessor.use(remarkHeading).run(mdast),
+        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, or a :::section directive with remark-directive configured.`
+        );
+      mdast = extracted;
+    } else {
+      mdast = await baseProcessor.run(mdast);
+    }
+    await update(mdast, path.dirname(file), data);
+    return mdast;
+  };
+  async function update(tree, directory, data) {
+    const queue = [];
+    visit2(tree, ElementLikeTypes, (_node, _, parent) => {
+      const node = _node;
+      if (node.name !== TagName) return;
+      const specifier = flattenNode(node);
+      if (specifier.length === 0) return "skip";
+      const attributes = parseElementAttributes(node);
+      const { file: relativePath, section } = parseSpecifier(specifier);
+      const file = path.resolve(
+        "cwd" in attributes ? process.cwd() : directory,
+        relativePath
+      );
+      queue.push(
+        embedContent(file, section, attributes, 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, path.dirname(file.path), file.data);
+  };
+}
+
+export {
+  remarkInclude
+};

package/dist/{chunk-VFALQK6O.js → chunk-KILFIBVW.js}

@@ -1,22 +1,29 @@
-// src/runtime/index.ts
+import {
+  createDocMethods
+} from "./chunk-NVRDCY6Z.js";
+
+// src/runtime/next/index.ts
 var _runtime = {
   doc(files) {
     return files.map((file) => {
-      const { default: body, frontmatter, ...exports } = file.data;
+      const data = file.data;
       return {
-        body,
-        ...exports,
-        ...frontmatter,
-        _exports: file.data,
-        _file: file.info
+        _exports: data,
+        body: data.default,
+        lastModified: data.lastModified,
+        toc: data.toc,
+        structuredData: data.structuredData,
+        extractedReferences: data.extractedReferences,
+        ...data.frontmatter,
+        ...createDocMethods(file.info, () => Promise.resolve(data))
       };
     });
   },
   meta(files) {
     return files.map((file) => {
       return {
-        ...file.data,
-        _file: file.info
+        info: file.info,
+        ...file.data
       };
     });
   },
@@ -34,7 +41,7 @@ var _runtime = {
 };
 function createMDXSource(docs, meta = []) {
   return {
-    files: () => resolveFiles({
+    files: resolveFiles({
       docs,
       meta
     })
@@ -45,14 +52,16 @@ function resolveFiles({ docs, meta }) {
   for (const entry of docs) {
     outputs.push({
       type: "page",
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }
   for (const entry of meta) {
     outputs.push({
       type: "meta",
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }

package/dist/chunk-NVRDCY6Z.js

@@ -0,0 +1,30 @@
+// src/runtime/shared.ts
+import fs from "fs/promises";
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        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 {
+  createDocMethods
+};

package/dist/chunk-U4MQ44TS.js

@@ -0,0 +1,53 @@
+// 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 } = await import("./preset-ZMP6U62C.js");
+        if (options?.preset === "minimal") return options;
+        return getDefaultMDXOptions({
+          ...options,
+          _withoutBundler: mode === "remote"
+        });
+      }
+      const result = uncached();
+      mdxOptionsCache.set(mode, result);
+      return result;
+    }
+  };
+}
+
+export {
+  buildConfig
+};

package/dist/chunk-VWJKRQZR.js

@@ -0,0 +1,19 @@
+// src/utils/fuma-matter.ts
+import { load } from "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 = load(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+export {
+  fumaMatter
+};

package/dist/chunk-XQ5O7IPO.js

@@ -0,0 +1,128 @@
+import {
+  buildMDX
+} from "./chunk-3J3WL7WN.js";
+import {
+  getGitTimestamp,
+  validate
+} from "./chunk-EELYB2XC.js";
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/loaders/mdx/index.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var querySchema = z.object({
+  only: z.literal(["frontmatter", "all"]).default("all"),
+  collection: z.string().optional()
+}).loose();
+var cacheEntry = z.object({
+  code: z.string(),
+  map: z.any().optional(),
+  hash: 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 config = await configLoader.getConfig();
+    let after;
+    if (!isDevelopment && config.global.experimentalBuildCache) {
+      const cacheDir = config.global.experimentalBuildCache;
+      const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+      const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      if (cached && cached.hash === generateCacheHash(value)) return cached;
+      after = async () => {
+        await fs.mkdir(cacheDir, { recursive: true });
+        await fs.writeFile(
+          path.join(cacheDir, cacheKey),
+          JSON.stringify({
+            ...out,
+            hash: generateCacheHash(value)
+          })
+        );
+      };
+    }
+    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
+    let docCollection;
+    switch (collection?.type) {
+      case "doc":
+        docCollection = collection;
+        break;
+      case "docs":
+        docCollection = collection.docs;
+        break;
+    }
+    if (docCollection?.schema) {
+      matter.data = await validate(
+        docCollection.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 (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 out = {
+      code: String(compiled.value),
+      map: compiled.map
+    };
+    await after?.();
+    return out;
+  };
+}
+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");
+}
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+export {
+  createMdxLoader
+};

package/dist/chunk-XZY2AWJI.js

@@ -0,0 +1,81 @@
+// src/utils/collections.ts
+import picomatch from "picomatch";
+import { glob } from "tinyglobby";
+import path from "path";
+var SupportedFormats = {
+  doc: ["mdx", "md"],
+  meta: ["json", "yaml"]
+};
+function getGlobPatterns(collection) {
+  if (collection.files) return collection.files;
+  return [`**/*.{${SupportedFormats[collection.type].join(",")}}`];
+}
+function isFileSupported(filePath, collection) {
+  return SupportedFormats[collection.type].some(
+    (format) => filePath.endsWith(`.${format}`)
+  );
+}
+function createCollectionMatcher(core) {
+  const CacheKey = "collection-matcher";
+  return {
+    scan(config) {
+      const scanned = [];
+      function scan(name, collection) {
+        const patterns = getGlobPatterns(collection);
+        for (const dir of Array.isArray(collection.dir) ? collection.dir : [collection.dir]) {
+          scanned.push({
+            name,
+            collection,
+            matcher: picomatch(patterns, {
+              cwd: dir
+            })
+          });
+        }
+      }
+      for (const [name, collection] of config.collections) {
+        if (collection.type === "docs") {
+          scan(name, collection.meta);
+          scan(name, collection.docs);
+        } else {
+          scan(name, collection);
+        }
+      }
+      return scanned;
+    },
+    getFileCollection(file) {
+      const scanned = core.cache.get(CacheKey) ?? this.scan(core.getConfig());
+      core.cache.set(CacheKey, scanned);
+      for (const item of scanned) {
+        if (isFileSupported(file, item.collection) && item.matcher(file))
+          return { name: item.name, collection: item.collection };
+      }
+    }
+  };
+}
+async function getCollectionFiles(collection) {
+  const files = /* @__PURE__ */ new Map();
+  const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+  const patterns = getGlobPatterns(collection);
+  await Promise.all(
+    dirs.map(async (dir) => {
+      const result = await glob(patterns, {
+        cwd: path.resolve(dir)
+      });
+      for (const item of result) {
+        if (!isFileSupported(item, collection)) continue;
+        const fullPath = path.join(dir, item);
+        files.set(fullPath, {
+          path: item,
+          fullPath
+        });
+      }
+    })
+  );
+  return Array.from(files.values());
+}
+
+export {
+  getGlobPatterns,
+  createCollectionMatcher,
+  getCollectionFiles
+};

package/dist/chunk-YVCR6FUH.js

@@ -0,0 +1,82 @@
+import {
+  ValidationError
+} from "./chunk-EELYB2XC.js";
+
+// src/loaders/adapter.ts
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+import { parse } from "querystring";
+import path from "path";
+function toNode(loader, filterByPath) {
+  return async (url, _context, nextLoad) => {
+    if (!url.startsWith("file:///")) return nextLoad(url);
+    const parsedUrl = new URL(url);
+    const filePath = fileURLToPath(parsedUrl);
+    if (filterByPath(filePath)) {
+      const source = (await fs.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);
+  };
+}
+function toVite(loader) {
+  return async function(file, query, value) {
+    const result = await loader({
+      filePath: file,
+      query: parse(query),
+      source: value,
+      development: this.environment.mode === "dev",
+      compiler: {
+        addDependency: (file2) => {
+          this.addWatchFile(file2);
+        }
+      }
+    });
+    return {
+      code: result.code,
+      map: result.map
+    };
+  };
+}
+function toWebpack(loader) {
+  return async function(source, callback) {
+    try {
+      const result = await loader({
+        filePath: this.resourcePath,
+        query: parse(this.resourceQuery.slice(1)),
+        source,
+        development: this.mode === "development",
+        compiler: this
+      });
+      callback(void 0, result.code, result.map);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return callback(new Error(error.toStringFormatted()));
+      }
+      if (!(error instanceof Error)) throw error;
+      const fpath = path.relative(this.context, this.resourcePath);
+      error.message = `${fpath}:${error.name}: ${error.message}`;
+      callback(error);
+    }
+  };
+}
+
+export {
+  toNode,
+  toVite,
+  toWebpack
+};