fumadocs-mdx 11.2.2 → 11.3.0

package/dist/index.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createMDXSource: () => createMDXSource,
+  toRuntime: () => toRuntime,
+  toRuntimeAsync: () => toRuntimeAsync
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runtime/resolve-files.ts
+function resolveFiles({
+  docs,
+  meta,
+  rootDir = ""
+}) {
+  const outputs = [];
+  for (const entry of docs) {
+    if (!entry._file.path.startsWith(rootDir)) continue;
+    outputs.push({
+      type: "page",
+      path: entry._file.path,
+      data: entry
+    });
+  }
+  for (const entry of meta) {
+    outputs.push({
+      type: "meta",
+      path: entry._file.path,
+      data: entry
+    });
+  }
+  return outputs;
+}
+
+// src/runtime/index.ts
+function toRuntime(type, file, info) {
+  if (type === "doc") {
+    const { default: body, frontmatter, ...exports2 } = file;
+    return {
+      body,
+      ...exports2,
+      ...frontmatter,
+      _exports: file,
+      _file: info
+    };
+  }
+  return {
+    ...file.default,
+    _file: info
+  };
+}
+function toRuntimeAsync(frontmatter, load, info) {
+  return {
+    async load() {
+      const { default: body, ...res } = await load();
+      return {
+        body,
+        ...res
+      };
+    },
+    ...frontmatter,
+    _file: info
+  };
+}
+function createMDXSource(docs, meta = []) {
+  return {
+    files: (rootDir) => resolveFiles({
+      docs,
+      meta,
+      rootDir
+    })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMDXSource,
+  toRuntime,
+  toRuntimeAsync
+});

package/dist/index.d.cts

@@ -0,0 +1,17 @@
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { F as FileInfo, B as BaseCollectionEntry } from './build-mdx-C2hor32E.cjs';
+import 'zod';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+import '@mdx-js/mdx';
+import 'unified';
+
+declare function toRuntime(type: 'doc' | 'meta', file: Record<string, unknown>, info: FileInfo): unknown;
+declare function toRuntimeAsync(frontmatter: Record<string, unknown>, load: () => Promise<Record<string, unknown>>, info: FileInfo): unknown;
+declare function createMDXSource<Doc extends PageData & BaseCollectionEntry, Meta extends MetaData & BaseCollectionEntry>(docs: Doc[], meta?: Meta[]): Source<{
+    pageData: Doc;
+    metaData: Meta;
+}>;
+
+export { createMDXSource, toRuntime, toRuntimeAsync };

package/dist/index.d.ts

@@ -1,13 +1,11 @@
 import { PageData, MetaData, Source } from 'fumadocs-core/source';
-import { F as FileInfo, B as BaseCollectionEntry } from './build-mdx-SZwWfZMp.js';
-import { MetaFile } from './loader-mdx.js';
+import { F as FileInfo, B as BaseCollectionEntry } from './build-mdx-C2hor32E.js';
 import 'zod';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';
 import 'fumadocs-core/server';
 import '@mdx-js/mdx';
 import 'unified';
-import 'webpack';
 
 declare function toRuntime(type: 'doc' | 'meta', file: Record<string, unknown>, info: FileInfo): unknown;
 declare function toRuntimeAsync(frontmatter: Record<string, unknown>, load: () => Promise<Record<string, unknown>>, info: FileInfo): unknown;
@@ -16,10 +14,4 @@ declare function createMDXSource<Doc extends PageData & BaseCollectionEntry, Met
     metaData: Meta;
 }>;
 
-interface Manifest {
-    files: (MetaFile & {
-        collection: string;
-    })[];
-}
-
-export { type Manifest, createMDXSource, toRuntime, toRuntimeAsync };
+export { createMDXSource, toRuntime, toRuntimeAsync };

package/dist/loader-mdx.cjs

@@ -0,0 +1,472 @@
+"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,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      import_mdx_plugins.remarkGfm,
+      [
+        import_mdx_plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [import_mdx_plugins.remarkImage, remarkImageOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        import_mdx_plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [import_mdx_plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      [import_mdx_plugins.rehypeToc]
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+var import_mdx_plugins;
+var init_mdx_options = __esm({
+  "src/utils/mdx-options.ts"() {
+    "use strict";
+    import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+    init_remark_exports();
+  }
+});
+
+// src/loader-mdx.ts
+var loader_mdx_exports = {};
+__export(loader_mdx_exports, {
+  default: () => loader
+});
+module.exports = __toCommonJS(loader_mdx_exports);
+var path4 = __toESM(require("path"), 1);
+var import_node_querystring = require("querystring");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/config/cached.ts
+var import_node_crypto = require("crypto");
+var fs = __toESM(require("fs"), 1);
+
+// src/config/load.ts
+var path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+async function loadConfig(configPath) {
+  const { build } = await import("esbuild");
+  const url = (0, import_node_url.pathToFileURL)(path.resolve(".source/source.config.mjs"));
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: ".source",
+    target: "node18",
+    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");
+  }
+  const loaded = await import(`${url.href}?hash=${Date.now().toString()}`);
+  const [err, config] = buildConfig(
+    // every call to `loadConfig` will cause the previous cache to be ignored
+    loaded
+  );
+  if (err !== null) throw new Error(err);
+  return config;
+}
+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/config/cached.ts
+var cache = /* @__PURE__ */ new Map();
+async function loadConfigCached(configPath, hash) {
+  const cached = cache.get(configPath);
+  if (cached && cached.hash === hash) {
+    return await cached.config;
+  }
+  const config = loadConfig(configPath);
+  cache.set(configPath, { config, hash });
+  return await config;
+}
+async function getConfigHash(configPath) {
+  const hash = (0, import_node_crypto.createHash)("md5");
+  const rs = fs.createReadStream(configPath);
+  for await (const chunk of rs) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+
+// src/utils/build-mdx.ts
+var import_mdx = require("@mdx-js/mdx");
+
+// src/mdx-plugins/remark-include.ts
+var import_unist_util_visit = require("unist-util-visit");
+var path2 = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs/promises"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function remarkInclude() {
+  return async (tree, file) => {
+    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 === "<include>" && content.type === "text" && closure.type === "html" && closure.value === "</include>") {
+          specifier = content.value.trim();
+        }
+      }
+      if (node.type === "mdxJsxFlowElement" && node.name === "include") {
+        const child = node.children.at(0);
+        if (!child || child.type !== "text") return;
+        specifier = child.value;
+      }
+      if (!specifier) return "skip";
+      const targetPath = path2.resolve(path2.dirname(file.path), specifier);
+      queue.push(
+        fs2.readFile(targetPath).then((content) => {
+          const parsed = this.parse((0, import_gray_matter.default)(content).content);
+          if (file.data._compiler) {
+            file.data._compiler.addDependency(targetPath);
+          }
+          Object.assign(node, parsed);
+        })
+      );
+      return "skip";
+    });
+    await Promise.all(queue);
+  };
+}
+
+// src/utils/build-mdx.ts
+var cache2 = /* @__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 = cache2.get(key);
+  if (cached === void 0 || cached.configHash !== configHash) {
+    cached = {
+      processor: (0, import_mdx.createProcessor)({
+        outputFormat: "program",
+        development: process.env.NODE_ENV === "development",
+        ...rest,
+        remarkPlugins: [remarkInclude, ...rest.remarkPlugins ?? []],
+        format
+      }),
+      configHash
+    };
+    cache2.set(key, cached);
+  }
+  return cached.processor.process({
+    value: source,
+    path: filePath,
+    data: {
+      ...data,
+      frontmatter,
+      _compiler: options._compiler
+    }
+  });
+}
+
+// src/utils/format-error.ts
+function formatError(message, 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 [message, ...lines].join("\n");
+}
+
+// src/utils/git-timestamp.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_cross_spawn = require("cross-spawn");
+var cache3 = /* @__PURE__ */ new Map();
+function getGitTimestamp(file) {
+  const cachedTimestamp = cache3.get(file);
+  if (cachedTimestamp) return Promise.resolve(cachedTimestamp);
+  return new Promise((resolve3, reject) => {
+    const cwd = import_node_path.default.dirname(file);
+    if (!import_node_fs.default.existsSync(cwd)) {
+      resolve3(void 0);
+      return;
+    }
+    const fileName = import_node_path.default.basename(file);
+    const child = (0, import_cross_spawn.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) cache3.set(file, output);
+      resolve3(output);
+    });
+    child.on("error", reject);
+  });
+}
+
+// src/loader-mdx.ts
+function parseQuery(query) {
+  let collection;
+  let hash;
+  const parsed = (0, import_node_querystring.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 { _ctx } = this.getOptions();
+  const matter2 = (0, import_gray_matter2.default)(source);
+  const {
+    hash: configHash = await getConfigHash(_ctx.configPath),
+    collection: collectionId
+  } = parseQuery(this.resourceQuery);
+  const config = await loadConfigCached(_ctx.configPath, configHash);
+  let collection = collectionId !== void 0 ? config.collections.get(collectionId) : void 0;
+  if (collection && collection.type !== "doc") {
+    collection = void 0;
+  }
+  const mdxOptions = collection?.mdxOptions ?? await config.getDefaultMDXOptions();
+  let frontmatter = matter2.data;
+  if (collection?.schema) {
+    let schema = collection.schema;
+    if (typeof schema === "function") {
+      schema = schema({
+        async buildMDX(v, options = mdxOptions) {
+          const res = await buildMDX(
+            collectionId ?? "global",
+            configHash,
+            v,
+            options
+          );
+          return String(res.value);
+        },
+        source,
+        path: filePath
+      });
+    }
+    const result = await schema.safeParseAsync(frontmatter);
+    if (result.error) {
+      callback(
+        new Error(
+          formatError(`invalid frontmatter in ${filePath}:`, result.error)
+        )
+      );
+      return;
+    }
+    frontmatter = result.data;
+  }
+  let timestamp;
+  if (config.global?.lastModifiedTime === "git")
+    timestamp = (await getGitTimestamp(filePath))?.getTime();
+  try {
+    const file = await buildMDX(
+      collectionId ?? "global",
+      configHash,
+      matter2.content,
+      {
+        development: this.mode === "development",
+        ...mdxOptions,
+        filePath,
+        frontmatter,
+        data: {
+          lastModified: timestamp
+        },
+        _compiler: this
+      }
+    );
+    callback(void 0, String(file.value), file.map ?? void 0);
+  } catch (error) {
+    if (!(error instanceof Error)) throw error;
+    const fpath = path4.relative(context, filePath);
+    error.message = `${fpath}:${error.name}: ${error.message}`;
+    callback(error);
+  }
+}

package/dist/loader-mdx.d.cts

@@ -0,0 +1,18 @@
+import { LoaderContext } from 'webpack';
+
+interface Options {
+    /**
+     * @internal
+     */
+    _ctx: {
+        configPath: string;
+    };
+}
+/**
+ * Load MDX/markdown files
+ *
+ * it supports frontmatter by parsing and injecting the data in `vfile.data.frontmatter`
+ */
+declare function loader(this: LoaderContext<Options>, source: string, callback: LoaderContext<Options>['callback']): Promise<void>;
+
+export { type Options, loader as default };

package/dist/loader-mdx.d.ts

@@ -1,5 +1,4 @@
 import { LoaderContext } from 'webpack';
-import { StructuredData } from 'fumadocs-core/mdx-plugins';
 
 interface Options {
     /**
@@ -9,14 +8,6 @@ interface Options {
         configPath: string;
     };
 }
-interface MetaFile {
-    path: string;
-    data: {
-        frontmatter: Record<string, unknown>;
-        structuredData?: StructuredData;
-        [key: string]: unknown;
-    };
-}
 /**
  * Load MDX/markdown files
  *
@@ -24,4 +15,4 @@ interface MetaFile {
  */
 declare function loader(this: LoaderContext<Options>, source: string, callback: LoaderContext<Options>['callback']): Promise<void>;
 
-export { type MetaFile, type Options, loader as default };
+export { type Options, loader as default };