fumadocs-mdx 11.6.0 → 13.0.1

package/dist/bun/index.d.cts

@@ -0,0 +1,13 @@
+import { BunPlugin } from 'bun';
+import { C as CoreOptions } from '../core-B6j6Fxse.cjs';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+
+type MdxPluginOptions = Partial<CoreOptions>;
+declare function createMdxPlugin(options?: MdxPluginOptions): BunPlugin;
+
+export { type MdxPluginOptions, createMdxPlugin };

package/dist/bun/index.d.ts

@@ -0,0 +1,13 @@
+import { BunPlugin } from 'bun';
+import { C as CoreOptions } from '../core-B6j6Fxse.js';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import 'chokidar';
+
+type MdxPluginOptions = Partial<CoreOptions>;
+declare function createMdxPlugin(options?: MdxPluginOptions): BunPlugin;
+
+export { type MdxPluginOptions, createMdxPlugin };

package/dist/bun/index.js

@@ -0,0 +1,62 @@
+import {
+  buildConfig
+} from "../chunk-U4MQ44TS.js";
+import {
+  createMdxLoader
+} from "../chunk-XQ5O7IPO.js";
+import "../chunk-3J3WL7WN.js";
+import "../chunk-K5ZLPEIQ.js";
+import {
+  createCore,
+  findConfigFile
+} from "../chunk-EELYB2XC.js";
+import "../chunk-VWJKRQZR.js";
+
+// src/bun/index.ts
+import { parse } from "querystring";
+import { pathToFileURL } from "url";
+function createMdxPlugin(options = {}) {
+  const {
+    environment = "bun",
+    outDir = ".source",
+    configPath = findConfigFile()
+  } = options;
+  async function getMdxLoader() {
+    const importPath = pathToFileURL(configPath).href;
+    const core = await createCore({
+      environment,
+      outDir,
+      configPath
+    }).init({
+      config: buildConfig(await import(importPath))
+    });
+    return createMdxLoader(core.creatConfigLoader());
+  }
+  return {
+    name: "bun-plugin-fumadocs-mdx",
+    setup(build) {
+      const mdxLoader = getMdxLoader();
+      build.onLoad({ filter: /\.mdx(\?.+?)?$/ }, async (args) => {
+        const [filePath, query] = args.path.split("?", 2);
+        const content = await Bun.file(filePath).text();
+        const result = await (await mdxLoader)({
+          source: content,
+          query: parse(query),
+          filePath,
+          development: false,
+          compiler: {
+            addDependency() {
+            }
+          }
+        });
+        return {
+          contents: result.code,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+export {
+  createMdxPlugin
+};

package/dist/chunk-3J3WL7WN.js

@@ -0,0 +1,160 @@
+import {
+  remarkInclude
+} from "./chunk-K5ZLPEIQ.js";
+
+// src/loaders/mdx/build-mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+
+// src/loaders/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";
+import { removePosition } from "unist-util-remove-position";
+import remarkMdx from "remark-mdx";
+function remarkPostprocess({
+  _format,
+  includeProcessedMarkdown = false,
+  includeMDAST = false,
+  valueToExport = []
+}) {
+  let _stringifyProcessor;
+  const getStringifyProcessor = () => {
+    if (_format === "mdx") return this;
+    return _stringifyProcessor ??= this().use(remarkMdx).freeze();
+  };
+  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) {
+      const processor = getStringifyProcessor();
+      file.data._markdown = toMarkdown(tree, {
+        ...processor.data("settings"),
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: processor.data("toMarkdownExtensions") || []
+      });
+    }
+    if (includeMDAST) {
+      const options = includeMDAST === true ? {} : includeMDAST;
+      file.data._mdast = JSON.stringify(
+        options.removePosition ? removePosition(structuredClone(tree)) : tree
+      );
+    }
+    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/loaders/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,
+            {
+              _format: format,
+              ...options.postprocess,
+              valueToExport: [
+                ...options.postprocess?.valueToExport ?? [],
+                "structuredData",
+                "extractedReferences",
+                "frontmatter",
+                "lastModified",
+                "_markdown",
+                "_mdast"
+              ]
+            }
+          ]
+        ],
+        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-CXA4JO4Z.js

@@ -0,0 +1,45 @@
+// src/utils/import-formatter.ts
+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");
+}
+
+export {
+  getImportCode,
+  toImportPath,
+  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-FSZMKRVH.js

@@ -0,0 +1,80 @@
+// src/loaders/mdx/preset.ts
+import * as plugins from "fumadocs-core/mdx-plugins";
+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,
+  remarkNpmOptions,
+  _withoutBundler = false,
+  ...mdxOptions
+}) {
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [
+        plugins.remarkImage,
+        {
+          ...remarkImageOptions,
+          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
+        }
+      ],
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+        plugins.remarkCodeTab,
+        remarkCodeTabOptions
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      () => {
+        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
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      plugins.rehypeToc
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    outputFormat: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+
+export {
+  getDefaultMDXOptions
+};

package/dist/chunk-II3H5ZVZ.js

@@ -0,0 +1,77 @@
+// src/runtime/vite/base.ts
+import { createElement, lazy } from "react";
+function fromConfigBase() {
+  function normalize(entries, base) {
+    const out = {};
+    for (const k in entries) {
+      const mappedK = k.startsWith("./") ? k.slice(2) : k;
+      if (base) Object.assign(entries[k], { base });
+      out[mappedK] = entries[k];
+    }
+    return out;
+  }
+  return {
+    doc(_, base, glob) {
+      return normalize(glob, base);
+    },
+    meta(_, base, glob) {
+      return normalize(glob, base);
+    },
+    docLazy(_, base, head, body) {
+      return {
+        base,
+        head: normalize(head),
+        body: normalize(body)
+      };
+    }
+  };
+}
+var loaderStore = /* @__PURE__ */ new Map();
+function createClientLoader(files, options) {
+  const { id = "", component } = options;
+  let renderer;
+  const store = loaderStore.get(id) ?? {
+    preloaded: /* @__PURE__ */ new Map()
+  };
+  loaderStore.set(id, store);
+  function getRenderer() {
+    if (renderer) return renderer;
+    renderer = {};
+    for (const k in files) {
+      const OnDemand = lazy(async () => {
+        const loaded = await files[k]();
+        return { default: (props) => component(loaded, props) };
+      });
+      renderer[k] = (props) => {
+        const cached = store.preloaded.get(k);
+        if (!cached) return createElement(OnDemand, props);
+        return component(cached, props);
+      };
+    }
+    return renderer;
+  }
+  return {
+    async preload(path) {
+      const loaded = await files[path]();
+      store.preloaded.set(path, loaded);
+      return loaded;
+    },
+    getRenderer,
+    getComponent(path) {
+      return getRenderer()[path];
+    },
+    useContent(path, props) {
+      const Comp = this.getComponent(path);
+      return createElement(Comp, props);
+    }
+  };
+}
+function toClientRenderer(files, component) {
+  return createClientLoader(files, { component }).getRenderer();
+}
+
+export {
+  fromConfigBase,
+  createClientLoader,
+  toClientRenderer
+};

package/dist/chunk-JVZFH6ND.js

@@ -0,0 +1,40 @@
+import {
+  buildConfig
+} from "./chunk-U4MQ44TS.js";
+
+// src/loaders/config/load.ts
+import * as path from "path";
+import { pathToFileURL } from "url";
+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, build = false) {
+  if (build) await compileConfig(configPath, outDir);
+  const url = pathToFileURL(path.resolve(outDir, "source.config.mjs"));
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+
+export {
+  loadConfig
+};