fumadocs-mdx 9.0.4 → 10.0.0

package/dist/index.mjs

@@ -1,111 +1,73 @@
-// src/resolve-files.ts
+// src/runtime/resolve-files.ts
 import path from "node:path";
-
-// src/utils/schema.ts
-import { z } from "zod";
-var metaSchema = z.object({
-  title: z.string().optional(),
-  pages: z.array(z.string()).optional(),
-  root: z.boolean().optional(),
-  defaultOpen: z.boolean().optional(),
-  icon: z.string().optional()
-});
-var frontmatterSchema = z.object({
-  title: z.string(),
-  description: z.string().optional(),
-  icon: z.string().optional(),
-  full: z.boolean().optional(),
-  // Fumadocs OpenAPI generated
-  _openapi: z.object({}).passthrough().optional()
-});
-var defaultSchemas = {
-  frontmatter: frontmatterSchema,
-  meta: metaSchema
-};
-
-// src/resolve-files.ts
 var pageTypes = [".md", ".mdx"];
-var metaTypes = [".json"];
-var DataError = class extends Error {
-  constructor(name, error) {
-    const info = error.flatten();
-    super(
-      `${name}: ${JSON.stringify(
-        {
-          root: info.formErrors,
-          ...info.fieldErrors
-        },
-        null,
-        2
-      )}`
-    );
-    this.name = "DataError";
-  }
-};
-function parse(schema, object, errorName) {
-  const result = schema.safeParse(object);
-  if (!result.success) {
-    throw new DataError(errorName, result.error);
-  }
-  return result.data;
-}
+var metaTypes = [".json", ".yaml"];
 function resolveFiles({
-  map,
-  rootDir = "",
-  schema = {}
+  docs,
+  meta,
+  rootDir = ""
 }) {
   const outputs = [];
-  for (const [file, value] of Object.entries(map)) {
-    if (!file.startsWith(rootDir)) continue;
-    const parsed = path.parse(file);
-    if (metaTypes.includes(parsed.ext)) {
+  for (const entry of docs) {
+    if (!entry._file.path.startsWith(rootDir)) continue;
+    const ext = path.extname(entry._file.path);
+    if (pageTypes.includes(ext)) {
       outputs.push({
-        type: "meta",
-        path: file,
-        data: parse(
-          schema.meta ?? defaultSchemas.meta,
-          value,
-          `Invalid meta file in ${file}`
-        )
+        type: "page",
+        path: entry._file.path,
+        data: entry
       });
       continue;
     }
-    if (pageTypes.includes(parsed.ext)) {
-      const { frontmatter, ...data } = value;
-      const parsedFrontmatter = parse(
-        schema.frontmatter ?? defaultSchemas.frontmatter,
-        frontmatter,
-        `Invalid Frontmatter in ${file}`
-      );
+    console.warn(
+      `Unknown Type: ${ext} on ${entry._file.path}, expected: ${pageTypes.toString()}`
+    );
+  }
+  for (const entry of meta) {
+    if (!entry._file.path.startsWith(rootDir)) continue;
+    const ext = path.extname(entry._file.path);
+    if (metaTypes.includes(ext)) {
       outputs.push({
-        type: "page",
-        path: file,
-        data: {
-          ...parsedFrontmatter,
-          exports: data
-        }
+        type: "meta",
+        path: entry._file.path,
+        data: entry
       });
       continue;
     }
-    console.warn("Unknown Type:", parsed.ext);
+    console.warn(
+      `Unknown Type: ${ext} on ${entry._file.path}, expected: ${metaTypes.toString()}`
+    );
   }
   return outputs;
 }
 
-// src/create.ts
-function createMDXSource(map, options) {
+// src/runtime/create.ts
+function toRuntime(type, file, info) {
+  if (type === "doc") {
+    const { default: body, frontmatter, ...exports } = file;
+    return {
+      body,
+      ...exports,
+      ...frontmatter,
+      _exports: file,
+      _file: info
+    };
+  }
   return {
-    files: (rootDir) => loadMDXSource(map, { ...options, rootDir })
+    ...file.default,
+    _file: info
   };
 }
-function loadMDXSource(map, options) {
-  return resolveFiles({
-    map,
-    ...options
-  });
+function createMDXSource(docs, meta) {
+  return {
+    files: (rootDir) => resolveFiles({
+      docs,
+      meta,
+      rootDir
+    })
+  };
 }
 export {
   createMDXSource,
-  defaultSchemas,
-  loadMDXSource
+  toRuntime
 };

package/dist/loader-mdx.d.mts

@@ -1,20 +1,20 @@
-import { ProcessorOptions } from '@mdx-js/mdx';
 import { LoaderContext } from 'webpack';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
 
-interface Options extends ProcessorOptions {
+interface Options {
     /**
-     * Fetch last modified time with specified version control
-     * @defaultValue 'none'
+     * @internal
      */
-    lastModifiedTime?: 'git' | 'none';
+    _ctx: {
+        configPath: string;
+    };
 }
-interface InternalBuildInfo {
-    __fumadocs?: {
-        path: string;
-        /**
-         * `vfile.data` parsed from file
-         */
-        data: unknown;
+interface MetaFile {
+    path: string;
+    data: {
+        frontmatter: Record<string, unknown>;
+        structuredData?: StructuredData;
+        [key: string]: unknown;
     };
 }
 /**
@@ -24,4 +24,4 @@ interface InternalBuildInfo {
  */
 declare function loader(this: LoaderContext<Options>, source: string, callback: LoaderContext<Options>['callback']): Promise<void>;
 
-export { type InternalBuildInfo, type Options, loader as default };
+export { type MetaFile, type Options, loader as default };

package/dist/loader-mdx.mjs

@@ -1,31 +1,116 @@
+import {
+  getConfigHash,
+  getKey,
+  loadConfigCached
+} from "./chunk-EKBKQCSU.mjs";
+import {
+  getDefaultMDXOptions
+} from "./chunk-LRV535YP.mjs";
+
 // src/loader-mdx.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import fs2 from "node:fs/promises";
-import { createProcessor } from "@mdx-js/mdx";
+import { parse } from "node:querystring";
 import grayMatter from "gray-matter";
 
-// src/utils/git-timestamp.ts
+// src/utils/find-collection.ts
 import path from "node:path";
+import micromatch from "micromatch";
+function findCollectionId(config, file, type) {
+  const cached = config._runtime.files.get(file);
+  if (cached) return cached;
+  for (const [name, collection] of config.collections.entries()) {
+    if (collection.type !== type) continue;
+    const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
+    const isInDir = dirs.some((dir) => {
+      const relative = path.relative(dir, path.dirname(file));
+      return !relative.startsWith("..") && !path.isAbsolute(relative);
+    });
+    if (!isInDir) continue;
+    const isIncluded = collection.files ? micromatch.isMatch(file, collection.files) : true;
+    if (!isIncluded) continue;
+    config._runtime.files.set(file, name);
+    return name;
+  }
+}
+
+// src/utils/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+var cache = /* @__PURE__ */ new Map();
+function cacheKey(group, format) {
+  return `${group}:${format}`;
+}
+function buildMDX(group, configHash, source, options = {}) {
+  const { filePath, frontmatter, data, ...rest } = options;
+  let format = options.format;
+  if (!format && filePath) {
+    format = filePath.endsWith(".mdx") ? "mdx" : "md";
+  }
+  format ??= "mdx";
+  const key = cacheKey(group, format);
+  let cached = cache.get(key);
+  if (cached === void 0 || cached.configHash !== configHash) {
+    cached = {
+      processor: createProcessor({
+        outputFormat: "program",
+        development: process.env.NODE_ENV === "development",
+        ...rest,
+        format
+      }),
+      configHash
+    };
+    cache.set(key, cached);
+  }
+  return cached.processor.process({
+    value: source,
+    path: filePath,
+    data: {
+      ...data,
+      frontmatter
+    }
+  });
+}
+
+// src/utils/format-error.ts
+function formatError(file, error) {
+  const lines = [];
+  function walk(key, { _errors, ...rest }, padStart = 0) {
+    if (key !== void 0 || _errors.length > 0) {
+      const text = key ? `${key}: ${_errors.join("\n    ")}` : _errors.join("\n");
+      lines.push(
+        text.split("\n").map((line) => `${" ".repeat(padStart)}${line}`).join("\n")
+      );
+    }
+    for (const [k, v] of Object.entries(rest)) {
+      walk(key ? `${key}.${k}` : k, v, padStart + 2);
+    }
+  }
+  walk(void 0, error.format());
+  return [`in ${file}:`, ...lines].join("\n");
+}
+
+// src/utils/git-timestamp.ts
+import path2 from "node:path";
 import fs from "node:fs";
 import { spawn } from "cross-spawn";
-var cache = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 function getGitTimestamp(file) {
-  const cachedTimestamp = cache.get(file);
+  const cachedTimestamp = cache2.get(file);
   if (cachedTimestamp) return Promise.resolve(cachedTimestamp);
   return new Promise((resolve, reject) => {
-    const cwd = path.dirname(file);
+    const cwd = path2.dirname(file);
     if (!fs.existsSync(cwd)) {
       resolve(void 0);
       return;
     }
-    const fileName = path.basename(file);
+    const fileName = path2.basename(file);
     const child = spawn("git", ["log", "-1", '--pretty="%ai"', fileName], {
       cwd
     });
     let output;
     child.stdout.on("data", (d) => output = new Date(String(d)));
     child.on("close", () => {
-      if (output) cache.set(file, output);
+      if (output) cache2.set(file, output);
       resolve(output);
     });
     child.on("error", reject);
@@ -33,55 +118,93 @@ function getGitTimestamp(file) {
 }
 
 // src/loader-mdx.ts
-var cache2 = /* @__PURE__ */ new Map();
+function getQuery(query) {
+  let collection;
+  let hash;
+  const parsed = parse(query.slice(1));
+  if (parsed.collection && typeof parsed.collection === "string")
+    collection = parsed.collection;
+  if (parsed.hash && typeof parsed.hash === "string") hash = parsed.hash;
+  return { collection, hash };
+}
 async function loader(source, callback) {
   this.cacheable(true);
   const context = this.context;
   const filePath = this.resourcePath;
-  const { lastModifiedTime, ...options } = this.getOptions();
-  const detectedFormat = filePath.endsWith(".mdx") ? "mdx" : "md";
-  const format = options.format ?? detectedFormat;
-  let processor = cache2.get(format);
-  if (processor === void 0) {
-    processor = createProcessor({
-      ...options,
-      development: this.mode === "development",
-      format
-    });
-    cache2.set(format, processor);
-  }
+  const { _ctx } = this.getOptions();
   const matter = grayMatter(source);
+  const query = getQuery(this.resourceQuery);
+  const configHash = query.hash ?? await getConfigHash(_ctx.configPath);
+  const config = await loadConfigCached(_ctx.configPath, configHash);
+  const collectionId = query.collection ?? findCollectionId(config, filePath, "doc");
+  const collection = collectionId !== void 0 ? config.collections.get(collectionId) : void 0;
+  const mdxOptions = collection?.mdxOptions ?? getDefaultMDXOptions(config.global?.mdxOptions ?? {});
+  function getTransformContext() {
+    return {
+      buildMDX: async (v, options = mdxOptions) => {
+        const res = await buildMDX(
+          collectionId ?? "global",
+          configHash,
+          v,
+          options
+        );
+        return String(res.value);
+      },
+      source,
+      path: filePath
+    };
+  }
+  let frontmatter = matter.data;
+  if (collection?.schema) {
+    const schema = typeof collection.schema === "function" ? collection.schema(getTransformContext()) : collection.schema;
+    const result = await schema.safeParseAsync(frontmatter);
+    if (result.error) {
+      callback(new Error(formatError(filePath, result.error)));
+      return;
+    }
+    frontmatter = result.data;
+  }
   const props = matter.data._mdx ?? {};
   if (props.mirror) {
-    const mirrorPath = path2.resolve(path2.dirname(filePath), props.mirror);
+    const mirrorPath = path3.resolve(path3.dirname(filePath), props.mirror);
     this.addDependency(mirrorPath);
     matter.content = await fs2.readFile(mirrorPath).then((res) => grayMatter(res.toString()).content);
   }
   let timestamp;
-  if (lastModifiedTime === "git")
+  if (config.global?.lastModifiedTime === "git")
     timestamp = (await getGitTimestamp(filePath))?.getTime();
-  processor.process({
-    value: matter.content,
-    path: filePath,
-    data: {
-      lastModified: timestamp,
-      frontmatter: matter.data
+  try {
+    const file = await buildMDX(
+      collectionId ?? "global",
+      configHash,
+      matter.content,
+      {
+        development: this.mode === "development",
+        ...mdxOptions,
+        filePath,
+        frontmatter,
+        data: {
+          lastModified: timestamp
+        }
+      }
+    );
+    callback(void 0, String(file.value), file.map ?? void 0);
+    if (config.global?.generateManifest) {
+      await fs2.mkdir(".next/cache/fumadocs", { recursive: true });
+      await fs2.writeFile(
+        path3.resolve(".next/cache/fumadocs", `${getKey(filePath)}.json`),
+        JSON.stringify({
+          path: filePath,
+          data: file.data
+        })
+      );
     }
-  }).then(
-    (file) => {
-      const info = this._module?.buildInfo;
-      info.__fumadocs = {
-        path: filePath,
-        data: file.data
-      };
-      callback(void 0, String(file.value), file.map ?? void 0);
-    },
-    (error) => {
-      const fpath = path2.relative(context, filePath);
-      error.message = `${fpath}:${error.name}: ${error.message}`;
-      callback(error);
-    }
-  );
+  } catch (error) {
+    if (!(error instanceof Error)) throw error;
+    const fpath = path3.relative(context, filePath);
+    error.message = `${fpath}:${error.name}: ${error.message}`;
+    callback(error);
+  }
 }
 export {
   loader as default

package/dist/next/index.d.mts

@@ -0,0 +1,13 @@
+import { NextConfig } from 'next';
+
+interface CreateMDXOptions {
+    /**
+     * Path to source configuration file
+     */
+    configPath?: string;
+}
+declare function createMDX({ configPath, }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
+
+declare function postInstall(configPath?: string): Promise<void>;
+
+export { type CreateMDXOptions, createMDX, postInstall };