fumadocs-mdx 12.0.3 → 13.0.1

package/dist/{chunk-6Y5JDZHD.js → chunk-CXA4JO4Z.js}

@@ -38,28 +38,8 @@ function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
 
-// src/utils/collections.ts
-function getSupportedFormats(collection) {
-  return {
-    doc: ["mdx", "md"],
-    meta: ["json", "yaml"]
-  }[collection.type];
-}
-function getGlobPatterns(collection) {
-  if (collection.files) return collection.files;
-  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
-}
-function isFileSupported(filePath, collection) {
-  for (const format of getSupportedFormats(collection)) {
-    if (filePath.endsWith(`.${format}`)) return true;
-  }
-  return false;
-}
-
 export {
   getImportCode,
   toImportPath,
-  ident,
-  getGlobPatterns,
-  isFileSupported
+  ident
 };

package/dist/chunk-EELYB2XC.js

@@ -0,0 +1,207 @@
+// src/loaders/config/index.ts
+import path from "path";
+import fs from "fs/promises";
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+function staticConfig({
+  core,
+  buildConfig
+}) {
+  let cached;
+  async function newConfig() {
+    const { loadConfig } = await import("./load-MNG3CLET.js");
+    await core.init({
+      config: loadConfig(
+        core._options.configPath,
+        core._options.outDir,
+        buildConfig
+      )
+    });
+    return core.getConfig();
+  }
+  return {
+    async getConfig() {
+      return cached ??= newConfig();
+    }
+  };
+}
+function dynamicConfig({
+  core,
+  buildConfig
+}) {
+  let loaded;
+  async function getConfigHash() {
+    const stats = await fs.stat(core._options.configPath).catch(() => void 0);
+    if (stats) {
+      return stats.mtime.getTime().toString();
+    }
+    throw new Error("Cannot find config file");
+  }
+  async function newConfig() {
+    const { loadConfig } = await import("./load-MNG3CLET.js");
+    await core.init({
+      config: loadConfig(
+        core._options.configPath,
+        core._options.outDir,
+        buildConfig
+      )
+    });
+    return core.getConfig();
+  }
+  return {
+    async getConfig() {
+      const hash = await getConfigHash();
+      if (loaded && loaded.hash === hash) return loaded.config;
+      loaded = {
+        hash,
+        config: newConfig()
+      };
+      return loaded.config;
+    }
+  };
+}
+
+// src/utils/validation.ts
+import picocolors from "picocolors";
+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 [
+      picocolors.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => picocolors.redBright(
+          `- ${picocolors.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/core.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+function createCore(options, defaultPlugins = []) {
+  let config;
+  let plugins;
+  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();
+      plugins = [];
+      for await (const option of [
+        ...defaultPlugins,
+        ...config.global.plugins ?? []
+      ]) {
+        if (!option) continue;
+        if (Array.isArray(option)) plugins.push(...option);
+        else plugins.push(option);
+      }
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(this.getPluginContext(), config);
+        if (out) config = out;
+      }
+      return this;
+    },
+    getConfig() {
+      return config;
+    },
+    creatConfigLoader() {
+      return {
+        getConfig() {
+          return config;
+        }
+      };
+    },
+    async initServer(server) {
+      for (const plugin of plugins) {
+        await plugin.configureServer?.call(this.getPluginContext(), server);
+      }
+    },
+    async emitAndWrite({
+      filterPlugin = () => true
+    } = {}) {
+      const start = performance.now();
+      const out = await Promise.all(
+        plugins.map((plugin) => {
+          if (!filterPlugin(plugin) || !plugin.emit) return [];
+          return plugin.emit.call(this.getPluginContext());
+        })
+      );
+      await Promise.all(
+        out.flat().map(async (entry) => {
+          const file = path2.join(options.outDir, entry.path);
+          await fs2.mkdir(path2.dirname(file), { recursive: true });
+          await fs2.writeFile(file, entry.content);
+        })
+      );
+      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    }
+  };
+}
+
+// src/utils/git-timestamp.ts
+import path3 from "path";
+import { x } from "tinyexec";
+var cache = /* @__PURE__ */ new Map();
+async function getGitTimestamp(file) {
+  const cached = cache.get(file);
+  if (cached) return cached;
+  try {
+    const out = await x(
+      "git",
+      ["log", "-1", '--pretty="%ai"', path3.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
+    );
+    const time = new Date(out.stdout);
+    cache.set(file, time);
+    return time;
+  } catch {
+    return;
+  }
+}
+
+export {
+  findConfigFile,
+  staticConfig,
+  dynamicConfig,
+  ValidationError,
+  validate,
+  getGitTimestamp,
+  createCore
+};

package/dist/{chunk-46UPKP5R.js → chunk-II3H5ZVZ.js}

@@ -1,7 +1,5 @@
-// src/runtime/vite/browser.ts
-import { createElement, lazy } from "react";
-
 // src/runtime/vite/base.ts
+import { createElement, lazy } from "react";
 function fromConfigBase() {
   function normalize(entries, base) {
     const out = {};
@@ -28,8 +26,6 @@ function fromConfigBase() {
     }
   };
 }
-
-// src/runtime/vite/browser.ts
 var loaderStore = /* @__PURE__ */ new Map();
 function createClientLoader(files, options) {
   const { id = "", component } = options;
@@ -63,6 +59,10 @@ function createClientLoader(files, options) {
     getRenderer,
     getComponent(path) {
       return getRenderer()[path];
+    },
+    useContent(path, props) {
+      const Comp = this.getComponent(path);
+      return createElement(Comp, props);
     }
   };
 }

package/dist/{chunk-LGYVNESJ.js → chunk-JVZFH6ND.js}

@@ -3,10 +3,8 @@ import {
 } from "./chunk-U4MQ44TS.js";
 
 // src/loaders/config/load.ts
-import * as fs from "fs/promises";
 import * as path from "path";
 import { pathToFileURL } from "url";
-var cache = null;
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -27,30 +25,16 @@ async function compileConfig(configPath, outDir) {
     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;
-  }
+async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
   const 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 };
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
   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");
-}
 
 export {
-  loadConfig,
-  getConfigHash
+  loadConfig
 };

package/dist/{chunk-LMG6UWCL.js → chunk-K5ZLPEIQ.js}

@@ -4,12 +4,56 @@ import {
 
 // src/loaders/mdx/remark-include.ts
 import { unified } from "unified";
-import { visit } from "unist-util-visit";
+import { visit as visit2 } from "unist-util-visit";
 import * as path from "path";
 import * as fs from "fs/promises";
-import remarkParse from "remark-parse";
-import remarkMdx from "remark-mdx";
 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",
@@ -49,7 +93,7 @@ function parseSpecifier(specifier) {
 function extractSection(root, section) {
   let nodes;
   let capturingHeadingContent = false;
-  visit(root, (node) => {
+  visit2(root, (node) => {
     if (node.type === "heading") {
       if (capturingHeadingContent) {
         return false;
@@ -81,7 +125,7 @@ function extractSection(root, section) {
 }
 function remarkInclude() {
   const TagName = "include";
-  async function embedContent(file, heading, params, data) {
+  const embedContent = async (file, heading, params, data) => {
     let content;
     try {
       content = (await fs.readFile(file)).toString();
@@ -104,18 +148,17 @@ ${e instanceof Error ? e.message : String(e)}`,
         data: {}
       };
     }
-    const parser = (data._getProcessor ?? getDefaultProcessor)(
-      ext === ".mdx" ? "mdx" : "md"
-    );
+    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 unified().use(remarkHeading).run(mdast),
+        await baseProcessor.use(remarkHeading).run(mdast),
         heading
       );
       if (!extracted)
@@ -123,13 +166,15 @@ ${e instanceof Error ? e.message : String(e)}`,
           `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 = [];
-    visit(tree, ElementLikeTypes, (_node, _, parent) => {
+    visit2(tree, ElementLikeTypes, (_node, _, parent) => {
       const node = _node;
       if (node.name !== TagName) return;
       const specifier = flattenNode(node);
@@ -156,11 +201,6 @@ ${e instanceof Error ? e.message : String(e)}`,
     await update(tree, path.dirname(file.path), file.data);
   };
 }
-function getDefaultProcessor(format) {
-  const mdProcessor = unified().use(remarkParse);
-  if (format === "md") return mdProcessor;
-  return mdProcessor.use(remarkMdx);
-}
 
 export {
   remarkInclude

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

@@ -1,16 +1,13 @@
 import {
-  missingProcessedMarkdown
-} from "./chunk-ZLCSVXCD.js";
+  createDocMethods
+} from "./chunk-NVRDCY6Z.js";
 
 // src/runtime/next/index.ts
-import * as fs from "fs/promises";
 var _runtime = {
   doc(files) {
     return files.map((file) => {
       const data = file.data;
-      const filePath = file.info.fullPath;
       return {
-        info: file.info,
         _exports: data,
         body: data.default,
         lastModified: data.lastModified,
@@ -18,13 +15,7 @@ var _runtime = {
         structuredData: data.structuredData,
         extractedReferences: data.extractedReferences,
         ...data.frontmatter,
-        async getText(type) {
-          if (type === "raw") {
-            return (await fs.readFile(filePath)).toString();
-          }
-          if (typeof data._markdown !== "string") missingProcessedMarkdown();
-          return data._markdown;
-        }
+        ...createDocMethods(file.info, () => Promise.resolve(data))
       };
     });
   },

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-RMDXSZYE.js → chunk-XQ5O7IPO.js}

@@ -1,10 +1,10 @@
 import {
   buildMDX
-} from "./chunk-QAUWMR5D.js";
+} from "./chunk-3J3WL7WN.js";
 import {
   getGitTimestamp,
   validate
-} from "./chunk-IQAEAI4P.js";
+} from "./chunk-EELYB2XC.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
@@ -16,10 +16,7 @@ import path from "path";
 import { createHash } from "crypto";
 var querySchema = z.object({
   only: z.literal(["frontmatter", "all"]).default("all"),
-  collection: z.string().optional(),
-  hash: z.string().describe(
-    "the hash of config, used for revalidation on Turbopack/Webpack."
-  ).optional()
+  collection: z.string().optional()
 }).loose();
 var cacheEntry = z.object({
   code: z.string(),
@@ -36,14 +33,25 @@ function createMdxLoader(configLoader) {
   }) => {
     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 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 ? loaded.collections.get(parsed.collection) : void 0;
+    const collection = parsed.collection ? config.collections.get(parsed.collection) : void 0;
     let docCollection;
     switch (collection?.type) {
       case "doc":
@@ -71,16 +79,16 @@ function createMdxLoader(configLoader) {
       };
     }
     const data = {};
-    if (loaded.global.lastModifiedTime === "git") {
+    if (config.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"}`,
+      `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
-        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
         postprocess: docCollection?.postprocess,
         data,
         filePath,
@@ -92,19 +100,18 @@ function createMdxLoader(configLoader) {
       code: String(compiled.value),
       map: compiled.map
     };
-    if (cacheDir) {
-      await fs.mkdir(cacheDir, { recursive: true });
-      await fs.writeFile(
-        path.join(cacheDir, cacheKey),
-        JSON.stringify({
-          ...out,
-          hash: generateCacheHash(value)
-        })
-      );
-    }
+    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");
 }

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-VXEBLM4X.js → chunk-YVCR6FUH.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-IQAEAI4P.js";
+} from "./chunk-EELYB2XC.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";