fumadocs-mdx 11.3.1 → 11.4.0

package/dist/runtime/async.cjs

@@ -0,0 +1,310 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mdx-plugins/remark-exports.ts
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            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_estree_util_value_to_estree;
+var init_remark_exports = __esm({
+  "src/mdx-plugins/remark-exports.ts"() {
+    "use strict";
+    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, {
+  getDefaultMDXOptions: () => getDefaultMDXOptions
+});
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  remarkCodeTabOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
+      // Fumadocs 14 compatibility
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && plugins.remarkCodeTab,
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      [plugins.rehypeToc]
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+var plugins;
+var init_mdx_options = __esm({
+  "src/utils/mdx-options.ts"() {
+    "use strict";
+    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
+    init_remark_exports();
+  }
+});
+
+// src/runtime/async.ts
+var async_exports = {};
+__export(async_exports, {
+  asyncFiles: () => asyncFiles,
+  buildConfig: () => buildConfig
+});
+module.exports = __toCommonJS(async_exports);
+var import_mdx_remote = require("@fumadocs/mdx-remote");
+var fs2 = __toESM(require("fs/promises"), 1);
+
+// src/mdx-plugins/remark-include.ts
+var import_unist_util_visit = require("unist-util-visit");
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs/promises"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function remarkInclude() {
+  const TagName = "include";
+  async function update(tree, file, processor, compiler) {
+    const queue = [];
+    (0, import_unist_util_visit.visit)(tree, ["mdxJsxFlowElement", "paragraph"], (node) => {
+      let specifier;
+      if (node.type === "paragraph" && node.children.length === 3) {
+        const [open, content, closure] = node.children;
+        if (open.type === "html" && open.value === `<${TagName}>` && content.type === "text" && closure.type === "html" && closure.value === `</${TagName}>`) {
+          specifier = content.value.trim();
+        }
+      } else if (node.type === "paragraph" && node.children.length === 1) {
+        const child = node.children[0];
+        if (child.type === "mdxJsxTextElement" && child.name === TagName) {
+          const text = child.children.at(0);
+          if (text && text.type === "text") {
+            specifier = text.value;
+          }
+        }
+      }
+      if (node.type === "mdxJsxFlowElement" && node.name === TagName) {
+        const child = node.children.at(0);
+        if (child && child.type === "text") {
+          specifier = child.value;
+        }
+      }
+      if (!specifier) return;
+      const targetPath = path.resolve(path.dirname(file), specifier);
+      queue.push(
+        fs.readFile(targetPath).then(async (content) => {
+          const parsed = processor.parse((0, import_gray_matter.default)(content).content);
+          compiler?.addDependency(targetPath);
+          await update(parsed, targetPath, processor, compiler);
+          Object.assign(node, parsed);
+        })
+      );
+      return "skip";
+    });
+    await Promise.all(queue);
+  }
+  return async (tree, file) => {
+    await update(tree, file.path, this, file.data._compiler);
+  };
+}
+
+// src/runtime/async.ts
+var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+
+// src/config/build.ts
+function buildConfig(config) {
+  const collections = /* @__PURE__ */ new Map();
+  let globalConfig;
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "_doc" in v && v._doc === "collections") {
+      collections.set(
+        k,
+        v
+      );
+      continue;
+    }
+    if (k === "default") {
+      globalConfig = v;
+      continue;
+    }
+    return [
+      `Unknown export "${k}", you can only export collections from source configuration file.`,
+      null
+    ];
+  }
+  let cachedMdxOptions;
+  return [
+    null,
+    {
+      global: globalConfig,
+      collections,
+      async getDefaultMDXOptions() {
+        if (cachedMdxOptions) return cachedMdxOptions;
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
+        const mdxOptions = globalConfig?.mdxOptions ?? {};
+        if (typeof mdxOptions === "function") {
+          cachedMdxOptions = getDefaultMDXOptions2(await mdxOptions());
+        } else {
+          cachedMdxOptions = getDefaultMDXOptions2(mdxOptions);
+        }
+        return cachedMdxOptions;
+      },
+      _runtime: {
+        files: /* @__PURE__ */ new Map()
+      }
+    }
+  ];
+}
+
+// src/runtime/async.ts
+function asyncFiles(files, collection, config) {
+  async function init() {
+    const col = config.collections.get(collection);
+    let mdxOptions;
+    if (col?.type === "doc" && col.mdxOptions) {
+      mdxOptions = col.mdxOptions;
+    } else {
+      const options = typeof config.global?.mdxOptions === "function" ? await config.global.mdxOptions() : config.global?.mdxOptions;
+      const remarkPlugins = options?.remarkPlugins ?? [];
+      mdxOptions = {
+        ...options,
+        remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), import_mdx_plugins.remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, import_mdx_plugins.remarkStructure]
+      };
+    }
+    return (0, import_mdx_remote.createCompiler)(mdxOptions);
+  }
+  const initCompiler = init();
+  return files.map(({ file, frontmatter }) => {
+    return {
+      ...frontmatter,
+      _file: file,
+      async load() {
+        const compiler = await initCompiler;
+        const out = await compiler.compile({
+          source: (await fs2.readFile(file.absolutePath)).toString(),
+          filePath: file.absolutePath
+        });
+        return {
+          body: out.body,
+          toc: out.toc,
+          structuredData: out.vfile.data.structuredData,
+          _exports: out.exports ?? {}
+        };
+      }
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asyncFiles,
+  buildConfig
+});

package/dist/runtime/async.d.cts

@@ -0,0 +1,35 @@
+import { G as GlobalConfig, F as FileInfo } from '../build-mdx-o0kbHSlp.cjs';
+import { D as DocCollection, M as MetaCollection } from '../define-BB9hRiTI.cjs';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import 'zod';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+import 'unified';
+import 'react';
+
+interface LoadedConfig {
+    collections: Map<string, InternalDocCollection | InternalMetaCollection>;
+    getDefaultMDXOptions: () => Promise<ProcessorOptions>;
+    global?: GlobalConfig;
+    _runtime: {
+        /**
+         * Absolute file path and their associated collections
+         */
+        files: Map<string, string>;
+    };
+}
+type InternalDocCollection = DocCollection;
+type InternalMetaCollection = MetaCollection;
+
+declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
+
+/**
+ * @internal
+ */
+declare function asyncFiles(files: {
+    file: FileInfo;
+    frontmatter: Record<string, unknown>;
+}[], collection: string, config: LoadedConfig): unknown[];
+
+export { asyncFiles, buildConfig };

package/dist/runtime/async.d.ts

@@ -0,0 +1,35 @@
+import { G as GlobalConfig, F as FileInfo } from '../build-mdx-o0kbHSlp.js';
+import { D as DocCollection, M as MetaCollection } from '../define-D3l733EX.js';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import 'zod';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+import 'unified';
+import 'react';
+
+interface LoadedConfig {
+    collections: Map<string, InternalDocCollection | InternalMetaCollection>;
+    getDefaultMDXOptions: () => Promise<ProcessorOptions>;
+    global?: GlobalConfig;
+    _runtime: {
+        /**
+         * Absolute file path and their associated collections
+         */
+        files: Map<string, string>;
+    };
+}
+type InternalDocCollection = DocCollection;
+type InternalMetaCollection = MetaCollection;
+
+declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
+
+/**
+ * @internal
+ */
+declare function asyncFiles(files: {
+    file: FileInfo;
+    frontmatter: Record<string, unknown>;
+}[], collection: string, config: LoadedConfig): unknown[];
+
+export { asyncFiles, buildConfig };

package/dist/runtime/async.js

@@ -0,0 +1,54 @@
+import {
+  remarkInclude
+} from "../chunk-PY2KKTR2.js";
+import {
+  buildConfig
+} from "../chunk-2DJQ3DOD.js";
+
+// src/runtime/async.ts
+import { createCompiler } from "@fumadocs/mdx-remote";
+import * as fs from "node:fs/promises";
+import {
+  remarkStructure
+} from "fumadocs-core/mdx-plugins";
+function asyncFiles(files, collection, config) {
+  async function init() {
+    const col = config.collections.get(collection);
+    let mdxOptions;
+    if (col?.type === "doc" && col.mdxOptions) {
+      mdxOptions = col.mdxOptions;
+    } else {
+      const options = typeof config.global?.mdxOptions === "function" ? await config.global.mdxOptions() : config.global?.mdxOptions;
+      const remarkPlugins = options?.remarkPlugins ?? [];
+      mdxOptions = {
+        ...options,
+        remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, remarkStructure]
+      };
+    }
+    return createCompiler(mdxOptions);
+  }
+  const initCompiler = init();
+  return files.map(({ file, frontmatter }) => {
+    return {
+      ...frontmatter,
+      _file: file,
+      async load() {
+        const compiler = await initCompiler;
+        const out = await compiler.compile({
+          source: (await fs.readFile(file.absolutePath)).toString(),
+          filePath: file.absolutePath
+        });
+        return {
+          body: out.body,
+          toc: out.toc,
+          structuredData: out.vfile.data.structuredData,
+          _exports: out.exports ?? {}
+        };
+      }
+    };
+  });
+}
+export {
+  asyncFiles,
+  buildConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "11.3.1",
+  "version": "11.4.0",
   "description": "The built-in source for Fumadocs",
   "keywords": [
     "NextJs",
@@ -23,6 +23,10 @@
       "types": "./dist/next/index.d.ts",
       "require": "./dist/next/index.cjs"
     },
+    "./runtime/async": {
+      "import": "./dist/runtime/async.js",
+      "types": "./dist/runtime/async.d.ts"
+    },
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
@@ -54,19 +58,26 @@
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
     "@types/micromatch": "^4.0.9",
-    "@types/react": "^19.0.7",
+    "@types/react": "^19.0.8",
     "mdast-util-mdx-jsx": "^3.2.0",
-    "next": "^15.1.4",
+    "next": "^15.1.6",
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
     "webpack": "^5.97.1",
+    "@fumadocs/mdx-remote": "1.1.3",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "14.7.4",
+    "fumadocs-core": "15.0.1",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "fumadocs-core": "^14.0.0",
-    "next": "14.x.x || 15.x.x"
+    "fumadocs-core": "^14.0.0 || ^15.0.0",
+    "next": "14.x.x || 15.x.x",
+    "@fumadocs/mdx-remote": "1.1.3"
+  },
+  "peerDependenciesMeta": {
+    "@fumadocs/mdx-remote": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public"