fumadocs-mdx 11.10.0 → 12.0.0

package/dist/runtime/{async.cjs → next/async.cjs}

@@ -30,86 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 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_visit2.visit)(tree, ["heading", "link"], (node) => {
-      if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode2(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 flattenNode2(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode2(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_visit2, import_estree_util_value_to_estree;
-var init_remark_postprocess = __esm({
-  "src/mdx-plugins/remark-postprocess.ts"() {
-    "use strict";
-    import_unist_util_visit2 = 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, {
+// src/mdx/preset.ts
+var preset_exports = {};
+__export(preset_exports, {
   getDefaultMDXOptions: () => getDefaultMDXOptions
 });
 function pluginOption(def, options = []) {
@@ -132,13 +55,6 @@ function getDefaultMDXOptions({
   _withoutBundler = false,
   ...mdxOptions
 }) {
-  const mdxExports = [
-    "structuredData",
-    "extractedReferences",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
   const remarkPlugins = pluginOption(
     (v) => [
       plugins.remarkGfm,
@@ -166,10 +82,15 @@ function getDefaultMDXOptions({
         plugins.remarkStructure,
         remarkStructureOptions
       ],
-      [
-        remarkPostprocess,
-        { injectExports: mdxExports }
-      ]
+      () => {
+        return (_, file) => {
+          file.data["mdx-export"] ??= [];
+          for (const name of valueToExport) {
+            if (name in file.data)
+              file.data["mdx-export"].push({ name, value: file.data[name] });
+          }
+        };
+      }
     ],
     mdxOptions.remarkPlugins
   );
@@ -189,15 +110,14 @@ function getDefaultMDXOptions({
   };
 }
 var plugins;
-var init_mdx_options = __esm({
-  "src/utils/mdx-options.ts"() {
+var init_preset = __esm({
+  "src/mdx/preset.ts"() {
     "use strict";
     plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-    init_remark_postprocess();
   }
 });
 
-// src/runtime/async.ts
+// src/runtime/next/async.ts
 var async_exports = {};
 __export(async_exports, {
   _runtimeAsync: () => _runtimeAsync,
@@ -205,26 +125,37 @@ __export(async_exports, {
 });
 module.exports = __toCommonJS(async_exports);
 
-// src/runtime/index.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var cache = /* @__PURE__ */ new Map();
+// src/runtime/next/index.ts
+var fs = __toESM(require("fs/promises"), 1);
+
+// src/runtime/shared.ts
+function missingProcessedMarkdown() {
+  throw new Error(
+    "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+  );
+}
+
+// src/runtime/next/index.ts
 var _runtime = {
   doc(files) {
     return files.map((file) => {
-      const { default: body, frontmatter, ...exports2 } = file.data;
+      const data = file.data;
+      const filePath = file.info.fullPath;
       return {
-        body,
-        ...exports2,
-        ...frontmatter,
-        _file: file.info,
-        _exports: file.data,
-        get content() {
-          const path2 = this._file.absolutePath;
-          const cached = cache.get(path2);
-          if (cached) return cached;
-          const content = import_node_fs.default.readFileSync(path2).toString();
-          cache.set(path2, content);
-          return content;
+        info: file.info,
+        _exports: data,
+        body: data.default,
+        lastModified: data.lastModified,
+        toc: data.toc,
+        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;
         }
       };
     });
@@ -232,8 +163,8 @@ var _runtime = {
   meta(files) {
     return files.map((file) => {
       return {
-        ...file.data,
-        _file: file.info
+        info: file.info,
+        ...file.data
       };
     });
   },
@@ -262,26 +193,26 @@ function resolveFiles({ docs, meta }) {
   for (const entry of docs) {
     outputs.push({
       type: "page",
-      absolutePath: entry._file.absolutePath,
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }
   for (const entry of meta) {
     outputs.push({
       type: "meta",
-      absolutePath: entry._file.absolutePath,
-      path: entry._file.path,
+      absolutePath: entry.info.fullPath,
+      path: entry.info.path,
       data: entry
     });
   }
   return outputs;
 }
 
-// src/utils/build-mdx.ts
+// src/mdx/build-mdx.ts
 var import_mdx = require("@mdx-js/mdx");
 
-// src/mdx-plugins/remark-include.ts
+// src/mdx/remark-include.ts
 var import_unified = require("unified");
 var import_unist_util_visit = require("unist-util-visit");
 var path = __toESM(require("path"), 1);
@@ -303,7 +234,7 @@ function fumaMatter(input) {
   return output;
 }
 
-// src/mdx-plugins/remark-include.ts
+// src/mdx/remark-include.ts
 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");
@@ -431,21 +362,121 @@ function getDefaultProcessor(format) {
   return mdProcessor.use(import_remark_mdx.default);
 }
 
-// src/utils/build-mdx.ts
-var cache2 = /* @__PURE__ */ new Map();
+// src/mdx/remark-postprocess.ts
+var import_unist_util_visit2 = require("unist-util-visit");
+var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
+var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+function remarkPostprocess({
+  includeProcessedMarkdown = false,
+  valueToExport = []
+} = {}) {
+  return (tree, file) => {
+    let title;
+    const urls = [];
+    (0, import_unist_util_visit2.visit)(tree, ["heading", "link"], (node) => {
+      if (node.type === "heading" && node.depth === 1) {
+        title = flattenNode2(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;
+    if (includeProcessedMarkdown) {
+      file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
+        ...this.data("settings"),
+        // @ts-expect-error - from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: this.data("toMarkdownExtensions") || []
+      });
+    }
+    for (const { name, value } of file.data["mdx-export"] ?? []) {
+      tree.children.unshift(getMdastExport(name, value));
+    }
+    for (const name of valueToExport) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
+}
+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)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+function flattenNode2(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode2(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+
+// src/mdx/build-mdx.ts
+var cache = /* @__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 = cache2.get(key);
+    let processor = cache.get(key);
     if (!processor) {
       processor = (0, import_mdx.createProcessor)({
         outputFormat: "program",
         ...rest,
-        remarkPlugins: [remarkInclude, ...rest.remarkPlugins ?? []],
+        remarkPlugins: [
+          remarkInclude,
+          ...rest.remarkPlugins ?? [],
+          [
+            remarkPostprocess,
+            {
+              ...options.postprocess,
+              valueToExport: [
+                ...options.postprocess?.valueToExport ?? [],
+                "structuredData",
+                "extractedReferences",
+                "frontmatter",
+                "lastModified",
+                "_markdown"
+              ]
+            }
+          ]
+        ],
         format
       });
-      cache2.set(key, processor);
+      cache.set(key, processor);
     }
     return processor;
   }
@@ -463,7 +494,7 @@ async function buildMDX(cacheKey, source, options) {
   });
 }
 
-// src/runtime/async.ts
+// src/runtime/next/async.ts
 var import_client = require("@fumadocs/mdx-remote/client");
 var import_node_url = require("url");
 
@@ -503,7 +534,7 @@ function buildConfig(config) {
       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));
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
         if (options?.preset === "minimal") return options;
         return getDefaultMDXOptions2({
           ...options,
@@ -517,42 +548,59 @@ function buildConfig(config) {
   };
 }
 
-// src/runtime/async.ts
-async function getOptions(config, collection) {
+// src/runtime/next/async.ts
+function getDocCollection(config, collection) {
   const col = config.collections.get(collection);
-  if (col?.type === "doc" && col.mdxOptions) return col.mdxOptions;
-  if (col?.type === "docs" && col.docs.mdxOptions) return col.docs.mdxOptions;
-  return config.getDefaultMDXOptions("remote");
+  if (col?.type === "doc" && col.mdxOptions) return col;
+  if (col?.type === "docs" && col.docs.mdxOptions) return col.docs;
+}
+async function getOptions(config, collection) {
+  return collection?.mdxOptions ?? await config.getDefaultMDXOptions("remote");
 }
 var _runtimeAsync = {
-  doc(files, collection, config) {
+  doc(files, collectionName, config) {
+    const collection = getDocCollection(config, collectionName);
     const initMdxOptions = getOptions(config, collection);
-    return files.map(({ info: file, data, content, lastModified }) => {
+    return files.map(({ info, data, content, lastModified }) => {
+      let cachedResult;
+      async function compileAndLoad() {
+        if (cachedResult) return cachedResult;
+        const mdxOptions = await initMdxOptions;
+        const compiled = await buildMDX(collectionName, content.body, {
+          ...mdxOptions,
+          development: false,
+          frontmatter: data,
+          postprocess: collection?.postprocess,
+          data: {
+            lastModified
+          },
+          filePath: info.fullPath
+        });
+        const result = await (0, import_client.executeMdx)(String(compiled.value), {
+          baseUrl: (0, import_node_url.pathToFileURL)(info.fullPath)
+        });
+        return cachedResult = result;
+      }
       return {
         ...data,
-        _file: file,
-        get content() {
-          return `${content.matter}${content.body}`;
+        info,
+        async getText(type) {
+          if (type === "raw") {
+            return `${content.matter}${content.body}`;
+          }
+          const out = await compileAndLoad();
+          if (typeof out._markdown !== "string") missingProcessedMarkdown();
+          return out._markdown;
         },
         async load() {
-          const mdxOptions = await initMdxOptions;
-          const out = await buildMDX(collection, content.body, {
-            ...mdxOptions,
-            development: false,
-            frontmatter: data,
-            data: {
-              lastModified
-            },
-            filePath: file.absolutePath
-          });
-          const { default: body, ...rest } = await (0, import_client.executeMdx)(String(out), {
-            baseUrl: (0, import_node_url.pathToFileURL)(file.absolutePath)
-          });
+          const out = await compileAndLoad();
           return {
-            structuredData: out.data.structuredData,
-            body,
-            ...rest,
-            lastModified
+            _exports: out,
+            body: out.default,
+            lastModified,
+            toc: out.toc,
+            extractedReferences: out.extractedReferences,
+            structuredData: out.structuredData
           };
         }
       };

package/dist/runtime/{async.d.cts → next/async.d.cts}

@@ -1,12 +1,12 @@
-import { L as LoadedConfig, a as RuntimeAsync } from '../types-DT83Ijs6.cjs';
+import { L as LoadedConfig, c as RuntimeAsync } from '../../types-Dl8HLbm5.cjs';
 import '@standard-schema/spec';
 import 'fumadocs-core/source';
-import '../define-BH4bnHQl.cjs';
+import '../../define--6HQ1ehX.cjs';
 import 'fumadocs-core/mdx-plugins';
 import '@mdx-js/mdx';
 import 'unified';
 import 'zod';
-import '../build-mdx-DnC1jKvn.cjs';
+import '../../shared-CqgMnt9h.cjs';
 import 'fumadocs-core/server';
 import 'react';
 import 'mdx/types';

package/dist/runtime/{async.d.ts → next/async.d.ts}

@@ -1,12 +1,12 @@
-import { L as LoadedConfig, a as RuntimeAsync } from '../types-DN9KrG7R.js';
+import { L as LoadedConfig, c as RuntimeAsync } from '../../types-DLIAvrgC.js';
 import '@standard-schema/spec';
 import 'fumadocs-core/source';
-import '../define-BH4bnHQl.js';
+import '../../define--6HQ1ehX.js';
 import 'fumadocs-core/mdx-plugins';
 import '@mdx-js/mdx';
 import 'unified';
 import 'zod';
-import '../build-mdx-DnC1jKvn.js';
+import '../../shared-0QIuV0XZ.js';
 import 'fumadocs-core/server';
 import 'react';
 import 'mdx/types';

package/dist/runtime/next/async.js

@@ -0,0 +1,92 @@
+import {
+  _runtime,
+  createMDXSource
+} from "../../chunk-AUOOMFAI.js";
+import {
+  missingProcessedMarkdown
+} from "../../chunk-ZLCSVXCD.js";
+import {
+  buildMDX
+} from "../../chunk-SWNOXPYJ.js";
+import "../../chunk-KTDVTBMH.js";
+import {
+  buildConfig
+} from "../../chunk-YC25YEBF.js";
+import "../../chunk-VWJKRQZR.js";
+
+// src/runtime/next/async.ts
+import { executeMdx } from "@fumadocs/mdx-remote/client";
+import { pathToFileURL } from "url";
+function getDocCollection(config, collection) {
+  const col = config.collections.get(collection);
+  if (col?.type === "doc" && col.mdxOptions) return col;
+  if (col?.type === "docs" && col.docs.mdxOptions) return col.docs;
+}
+async function getOptions(config, collection) {
+  return collection?.mdxOptions ?? await config.getDefaultMDXOptions("remote");
+}
+var _runtimeAsync = {
+  doc(files, collectionName, config) {
+    const collection = getDocCollection(config, collectionName);
+    const initMdxOptions = getOptions(config, collection);
+    return files.map(({ info, data, content, lastModified }) => {
+      let cachedResult;
+      async function compileAndLoad() {
+        if (cachedResult) return cachedResult;
+        const mdxOptions = await initMdxOptions;
+        const compiled = await buildMDX(collectionName, content.body, {
+          ...mdxOptions,
+          development: false,
+          frontmatter: data,
+          postprocess: collection?.postprocess,
+          data: {
+            lastModified
+          },
+          filePath: info.fullPath
+        });
+        const result = await executeMdx(String(compiled.value), {
+          baseUrl: pathToFileURL(info.fullPath)
+        });
+        return cachedResult = result;
+      }
+      return {
+        ...data,
+        info,
+        async getText(type) {
+          if (type === "raw") {
+            return `${content.matter}${content.body}`;
+          }
+          const out = await compileAndLoad();
+          if (typeof out._markdown !== "string") missingProcessedMarkdown();
+          return out._markdown;
+        },
+        async load() {
+          const out = await compileAndLoad();
+          return {
+            _exports: out,
+            body: out.default,
+            lastModified,
+            toc: out.toc,
+            extractedReferences: out.extractedReferences,
+            structuredData: out.structuredData
+          };
+        }
+      };
+    });
+  },
+  docs(docs, metas, collection, config) {
+    const parsedDocs = this.doc(docs, collection, config);
+    const parsedMetas = _runtime.meta(metas);
+    return {
+      docs: parsedDocs,
+      meta: parsedMetas,
+      toFumadocsSource() {
+        return createMDXSource(parsedDocs, parsedMetas);
+      }
+    };
+  }
+};
+export {
+  _runtimeAsync,
+  buildConfig
+};