fumadocs-mdx 13.0.8 → 14.0.0

package/dist/chunk-PKI7ZDA5.js

@@ -0,0 +1,29 @@
+// src/utils/codegen/cache.ts
+import { LRUCache } from "lru-cache";
+import fs from "fs/promises";
+import path from "path";
+var map = new LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (path.isAbsolute(file)) {
+    return path.relative(process.cwd(), file);
+  }
+  return file;
+}
+async function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = fs.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+export {
+  readFileWithCache,
+  removeFileCache
+};

package/dist/{chunk-3J3WL7WN.js → chunk-SLY7WXTX.js}

@@ -1,9 +1,11 @@
 import {
+  flattenNode,
   remarkInclude
-} from "./chunk-K5ZLPEIQ.js";
+} from "./chunk-FBLMK4RS.js";
 
 // src/loaders/mdx/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";
+import { VFile } from "vfile";
 
 // src/loaders/mdx/remark-postprocess.ts
 import { visit } from "unist-util-visit";
@@ -15,48 +17,66 @@ function remarkPostprocess({
   _format,
   includeProcessedMarkdown = false,
   includeMDAST = false,
+  extractLinkReferences = false,
   valueToExport = []
 }) {
   let _stringifyProcessor;
   const getStringifyProcessor = () => {
-    if (_format === "mdx") return this;
-    return _stringifyProcessor ??= this().use(remarkMdx).freeze();
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(remarkMdx).freeze()
+    );
   };
   return (tree, file) => {
-    let title;
-    const urls = [];
-    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
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      visit(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    if (extractLinkReferences) {
+      const urls = [];
+      visit(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
       });
-      return "skip";
-    });
-    if (title) {
-      file.data.frontmatter ??= {};
-      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
     }
-    file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
       const processor = getStringifyProcessor();
-      file.data._markdown = toMarkdown(tree, {
+      const markdown = toMarkdown(tree, {
         ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
         extensions: processor.data("toMarkdownExtensions") || []
       });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
     }
     if (includeMDAST) {
       const options = includeMDAST === true ? {} : includeMDAST;
-      file.data._mdast = JSON.stringify(
+      const mdast = JSON.stringify(
         options.removePosition ? removePosition(structuredClone(tree)) : tree
       );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
     }
-    for (const { name, value } of file.data["mdx-export"] ?? []) {
+    for (const { name, value } of file.data["mdx-export"]) {
       tree.children.unshift(getMdastExport(name, value));
     }
+    file.data["mdx-export"] = [];
     for (const name of valueToExport) {
       if (!(name in file.data)) continue;
       tree.children.unshift(getMdastExport(name, file.data[name]));
@@ -97,43 +117,39 @@ function getMdastExport(name, value) {
     }
   };
 }
-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/build-mdx.ts
-var cache = /* @__PURE__ */ new Map();
-async function buildMDX(cacheKey, source, options) {
-  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+async function buildMDX(core, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
   function getProcessor(format) {
-    const key = `${cacheKey}:${format}`;
+    const cache = core.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
     let processor = cache.get(key);
     if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess,
+        valueToExport: [
+          ...collection?.postprocess?.valueToExport ?? [],
+          "structuredData",
+          "frontmatter"
+        ]
+      };
       processor = createProcessor({
         outputFormat: "program",
-        ...rest,
+        development: isDevelopment,
+        ...mdxOptions,
         remarkPlugins: [
           remarkInclude,
-          ...rest.remarkPlugins ?? [],
-          [
-            remarkPostprocess,
-            {
-              _format: format,
-              ...options.postprocess,
-              valueToExport: [
-                ...options.postprocess?.valueToExport ?? [],
-                "structuredData",
-                "extractedReferences",
-                "frontmatter",
-                "lastModified",
-                "_markdown",
-                "_mdast"
-              ]
-            }
-          ]
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
         ],
         format
       });
@@ -141,18 +157,15 @@ async function buildMDX(cacheKey, source, options) {
     }
     return processor;
   }
-  return getProcessor(
-    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
-  ).process({
+  let vfile = new VFile({
     value: source,
     path: filePath,
-    data: {
-      ...data,
-      frontmatter,
-      _compiler,
-      _getProcessor: getProcessor
-    }
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
+  if (collection) {
+    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
 }
 
 export {

package/dist/{chunk-5FTSWCB4.js → chunk-SRSRFOVI.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-2AQRQXSO.js";
+} from "./chunk-7L2KNF6B.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";
@@ -83,7 +83,7 @@ function toWebpack(loader) {
       }
     } 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 = path.relative(this.context, this.resourcePath);
@@ -115,8 +115,8 @@ function toBun(loader) {
           }
         }
       };
-      if (loader.bun?.loadSync) {
-        return loader.bun.loadSync(readFileSync(filePath).toString(), input);
+      if (loader.bun?.load) {
+        return loader.bun.load(readFileSync(filePath).toString(), input);
       }
       const result = loader.load(input);
       if (result instanceof Promise) {
@@ -143,17 +143,14 @@ function createStandaloneConfigLoader({
     return stats.mtime.getTime().toString();
   }
   async function newConfig() {
-    const { loadConfig } = await import("./load-from-file-AVYOFOI7.js");
+    const { loadConfig } = await import("./load-from-file-I3ALLIVB.js");
     await core.init({
-      config: loadConfig(
-        core._options.configPath,
-        core._options.outDir,
-        buildConfig
-      )
+      config: loadConfig(core, buildConfig)
     });
     return core.getConfig();
   }
   return {
+    core,
     async getConfig() {
       const hash = await getConfigHash();
       if (loaded && loaded.hash === hash) return loaded.config;
@@ -167,6 +164,7 @@ function createStandaloneConfigLoader({
 }
 function createIntegratedConfigLoader(core) {
   return {
+    core,
     getConfig() {
       return core.getConfig();
     }

package/dist/chunk-TYJDYTKH.js

@@ -0,0 +1,85 @@
+import {
+  metaLoaderGlob
+} from "./chunk-4JSFLXXT.js";
+
+// src/loaders/meta.ts
+import { dump, load } from "js-yaml";
+import { z } from "zod";
+var querySchema = z.object({
+  collection: z.string().optional()
+}).loose();
+function createMetaLoader(configLoader, resolve = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
+  function parse(filePath, source) {
+    try {
+      if (filePath.endsWith(".json")) return JSON.parse(source);
+      if (filePath.endsWith(".yaml")) return load(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
+    throw new Error("Unknown file type " + filePath);
+  }
+  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":
+          metaCollection = collection;
+          break;
+        case "docs":
+          metaCollection = collection.meta;
+          break;
+      }
+      const data = parse(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" ? dump(data) : `export default ${JSON.stringify(data)}`
+        };
+      }
+    },
+    bun: {
+      load(source, input) {
+        const result = onMeta(source, input);
+        if (result === null)
+          return {
+            loader: "object",
+            exports: parse(input.filePath, source)
+          };
+        return result().then((data) => ({
+          loader: "object",
+          exports: { default: data }
+        }));
+      }
+    }
+  };
+}
+
+export {
+  createMetaLoader
+};