fumadocs-mdx 11.10.0 → 12.0.0

package/dist/{chunk-NUDEC6C5.js → chunk-AUOOMFAI.js}

@@ -1,23 +1,29 @@
-// src/runtime/index.ts
-import fs from "fs";
-var cache = /* @__PURE__ */ new Map();
+import {
+  missingProcessedMarkdown
+} from "./chunk-ZLCSVXCD.js";
+
+// src/runtime/next/index.ts
+import * as fs from "fs/promises";
 var _runtime = {
   doc(files) {
     return files.map((file) => {
-      const { default: body, frontmatter, ...exports } = file.data;
+      const data = file.data;
+      const filePath = file.info.fullPath;
       return {
-        body,
-        ...exports,
-        ...frontmatter,
-        _file: file.info,
-        _exports: file.data,
-        get content() {
-          const path = this._file.absolutePath;
-          const cached = cache.get(path);
-          if (cached) return cached;
-          const content = fs.readFileSync(path).toString();
-          cache.set(path, 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;
         }
       };
     });
@@ -25,8 +31,8 @@ var _runtime = {
   meta(files) {
     return files.map((file) => {
       return {
-        ...file.data,
-        _file: file.info
+        info: file.info,
+        ...file.data
       };
     });
   },
@@ -55,16 +61,16 @@ 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
     });
   }

package/dist/chunk-IQAEAI4P.js

@@ -0,0 +1,66 @@
+// 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/utils/git-timestamp.ts
+import path 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"', path.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
+    );
+    const time = new Date(out.stdout);
+    cache.set(file, time);
+    return time;
+  } catch {
+    return;
+  }
+}
+
+export {
+  ValidationError,
+  validate,
+  getGitTimestamp
+};

package/dist/{chunk-5XJM5RPV.js → chunk-KGUBBRL6.js}

@@ -1,12 +1,14 @@
 import {
-  getConfigHash,
   getGitTimestamp,
-  loadConfig,
   validate
-} from "./chunk-2HKRTQYP.js";
+} from "./chunk-IQAEAI4P.js";
+import {
+  getConfigHash,
+  loadConfig
+} from "./chunk-POXTQZ4D.js";
 import {
   buildMDX
-} from "./chunk-QQWCBFFE.js";
+} from "./chunk-SWNOXPYJ.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
@@ -55,21 +57,18 @@ function createMdxLoader(configLoader) {
       if (cached && cached.hash === generateCacheHash(value)) return cached;
     }
     const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
-    let schema;
-    let mdxOptions;
+    let docCollection;
     switch (collection?.type) {
       case "doc":
-        mdxOptions = collection.mdxOptions;
-        schema = collection.schema;
+        docCollection = collection;
         break;
       case "docs":
-        mdxOptions = collection.docs.mdxOptions;
-        schema = collection.docs.schema;
+        docCollection = collection.docs;
         break;
     }
-    if (schema) {
+    if (docCollection?.schema) {
       matter.data = await validate(
-        schema,
+        docCollection.schema,
         matter.data,
         {
           source: value,
@@ -94,7 +93,8 @@ function createMdxLoader(configLoader) {
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
-        ...mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        postprocess: docCollection?.postprocess,
         data,
         filePath,
         frontmatter: matter.data,

package/dist/{chunk-SVTXMVLQ.js → chunk-KTDVTBMH.js}

@@ -2,7 +2,7 @@ import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
 
-// src/mdx-plugins/remark-include.ts
+// src/mdx/remark-include.ts
 import { unified } from "unified";
 import { visit } from "unist-util-visit";
 import * as path from "path";

package/dist/chunk-POXTQZ4D.js

@@ -0,0 +1,60 @@
+import {
+  buildConfig
+} from "./chunk-YC25YEBF.js";
+
+// src/utils/config.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { pathToFileURL } from "url";
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+var cache = null;
+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",
+    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 = 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");
+}
+
+export {
+  findConfigFile,
+  loadConfig,
+  getConfigHash
+};

package/dist/chunk-SWNOXPYJ.js

@@ -0,0 +1,142 @@
+import {
+  remarkInclude
+} from "./chunk-KTDVTBMH.js";
+
+// src/mdx/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+
+// src/mdx/remark-postprocess.ts
+import { visit } from "unist-util-visit";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { valueToEstree } from "estree-util-value-to-estree";
+function remarkPostprocess({
+  includeProcessedMarkdown = false,
+  valueToExport = []
+} = {}) {
+  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
+      });
+      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 = 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: valueToEstree(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/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 = cache.get(key);
+    if (!processor) {
+      processor = createProcessor({
+        outputFormat: "program",
+        ...rest,
+        remarkPlugins: [
+          remarkInclude,
+          ...rest.remarkPlugins ?? [],
+          [
+            remarkPostprocess,
+            {
+              ...options.postprocess,
+              valueToExport: [
+                ...options.postprocess?.valueToExport ?? [],
+                "structuredData",
+                "extractedReferences",
+                "frontmatter",
+                "lastModified",
+                "_markdown"
+              ]
+            }
+          ]
+        ],
+        format
+      });
+      cache.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
+    }
+  });
+}
+
+export {
+  buildMDX
+};

package/dist/{chunk-COQ4VMK2.js → chunk-TLD6JMT6.js}

@@ -1,42 +1,16 @@
-// src/utils/import-formatter.ts
+import {
+  getGlobPatterns,
+  ident,
+  toImportPath
+} from "./chunk-6Y5JDZHD.js";
+import {
+  findConfigFile,
+  loadConfig
+} from "./chunk-POXTQZ4D.js";
+
+// src/vite/postinstall.ts
+import fs from "fs/promises";
 import path from "path";
-function getImportCode(info) {
-  const specifier = JSON.stringify(info.specifier);
-  if (info.type === "default") return `import ${info.name} from ${specifier}`;
-  if (info.type === "namespace")
-    return `import * as ${info.name} from ${specifier}`;
-  if (info.type === "named") {
-    const names = info.names.map(
-      (name) => Array.isArray(name) ? `${name[0]} as ${name[1]}` : name
-    );
-    return `import { ${names.join(", ")} } from ${specifier}`;
-  }
-  return `import ${specifier}`;
-}
-function toImportPath(file, config) {
-  const ext = path.extname(file);
-  let filename;
-  if (ext === ".ts" && config.jsExtension) {
-    filename = file.substring(0, file.length - ext.length) + ".js";
-  } else if (ext === ".ts") {
-    filename = file.substring(0, file.length - ext.length);
-  } else {
-    filename = file;
-  }
-  let importPath;
-  if ("relativeTo" in config) {
-    importPath = path.relative(config.relativeTo, filename);
-    if (!path.isAbsolute(importPath) && !importPath.startsWith(".")) {
-      importPath = `./${importPath}`;
-    }
-  } else {
-    importPath = path.resolve(filename);
-  }
-  return importPath.replaceAll(path.sep, "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
 
 // src/vite/generate-glob.ts
 function generateGlob(name, patterns, globOptions) {
@@ -69,24 +43,6 @@ function getGlobBase(collection) {
   return enforceRelative(dir);
 }
 
-// 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;
-}
-
 // src/vite/generate.ts
 function docs(name, collection) {
   const obj = [
@@ -149,10 +105,21 @@ function entry(configPath, config, outDir, jsExtension) {
   return lines.join("\n");
 }
 
+// src/vite/postinstall.ts
+async function postInstall(configPath = findConfigFile(), outDir, addJsExtension = false) {
+  const config = await loadConfig(configPath, "node_modules", void 0, true);
+  const outFile = "source.generated.ts";
+  if (outDir) {
+    await fs.mkdir(outDir, { recursive: true });
+  }
+  await fs.writeFile(
+    outDir ? path.join(outDir, outFile) : outFile,
+    entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
+  );
+  console.log("[MDX] types generated");
+}
+
 export {
-  getImportCode,
-  toImportPath,
-  getGlobPatterns,
-  isFileSupported,
-  entry
+  entry,
+  postInstall
 };

package/dist/{chunk-NVX3U5YE.js → chunk-VXEBLM4X.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-2HKRTQYP.js";
+} from "./chunk-IQAEAI4P.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";
@@ -57,7 +57,7 @@ function toWebpack(loader) {
     try {
       const result = await loader({
         filePath: this.resourcePath,
-        query: parse(this.resourceQuery),
+        query: parse(this.resourceQuery.slice(1)),
         source,
         development: this.mode === "development",
         compiler: this

package/dist/{chunk-QVZ7JH4H.js → chunk-YC25YEBF.js}

@@ -34,7 +34,7 @@ function buildConfig(config) {
       const input = this.global.mdxOptions;
       async function uncached() {
         const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions } = await import("./mdx-options-T73E4LQB.js");
+        const { getDefaultMDXOptions } = await import("./preset-WFEORCAB.js");
         if (options?.preset === "minimal") return options;
         return getDefaultMDXOptions({
           ...options,

package/dist/chunk-ZLCSVXCD.js

@@ -0,0 +1,10 @@
+// src/runtime/shared.ts
+function missingProcessedMarkdown() {
+  throw new Error(
+    "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+  );
+}
+
+export {
+  missingProcessedMarkdown
+};