fumadocs-mdx 13.0.8 → 14.0.1

package/dist/node/loader.js

@@ -1,27 +1,26 @@
 import {
   createMdxLoader
-} from "../chunk-2E2JCOSO.js";
+} from "../chunk-6NISOLQ6.js";
 import {
   createMetaLoader
-} from "../chunk-DMJ6I4C3.js";
+} from "../chunk-TYJDYTKH.js";
 import {
   createStandaloneConfigLoader,
   toNode
-} from "../chunk-5FTSWCB4.js";
-import "../chunk-3J3WL7WN.js";
-import "../chunk-K5ZLPEIQ.js";
-import "../chunk-VUEZTR2H.js";
+} from "../chunk-K6HCOGOX.js";
+import "../chunk-4JSFLXXT.js";
 import {
-  createCore,
-  findConfigFile
-} from "../chunk-2AQRQXSO.js";
+  _Defaults,
+  createCore
+} from "../chunk-BEBCWQC7.js";
+import "../chunk-WBIHDYMN.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/node/loader.ts
 var core = createCore({
   environment: "node",
-  configPath: findConfigFile(),
-  outDir: ".source"
+  configPath: _Defaults.configPath,
+  outDir: _Defaults.outDir
 });
 var configLoader = createStandaloneConfigLoader({
   core,

package/dist/plugins/index-file.cjs

@@ -0,0 +1,495 @@
+"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 __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/plugins/index-file.ts
+var index_file_exports = {};
+__export(index_file_exports, {
+  default: () => indexFile
+});
+module.exports = __toCommonJS(index_file_exports);
+var import_path = __toESM(require("path"), 1);
+
+// src/utils/codegen.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_tinyglobby = require("tinyglobby");
+function createCodegen({
+  target = "default",
+  outDir = "",
+  jsExtension = false,
+  globCache = /* @__PURE__ */ new Map()
+}) {
+  let eagerImportId = 0;
+  const banner = ["// @ts-nocheck"];
+  if (target === "vite") {
+    banner.push('/// <reference types="vite/client" />');
+  }
+  return {
+    options: {
+      target,
+      outDir
+    },
+    lines: [],
+    addImport(statement) {
+      this.lines.unshift(statement);
+    },
+    async pushAsync(insert) {
+      for (const line of await Promise.all(insert)) {
+        if (line === void 0) continue;
+        this.lines.push(line);
+      }
+    },
+    async generateGlobImport(patterns, options) {
+      if (target === "vite") {
+        return this.generateViteGlobImport(patterns, options);
+      }
+      return this.generateNodeGlobImport(patterns, options);
+    },
+    generateViteGlobImport(patterns, { base, ...rest }) {
+      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+        normalizeViteGlobPath
+      );
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          base: normalizeViteGlobPath(import_node_path.default.relative(outDir, base)),
+          ...rest
+        },
+        null,
+        2
+      )})`;
+    },
+    async generateNodeGlobImport(patterns, {
+      base,
+      eager = false,
+      query = {},
+      import: importName
+    }) {
+      const cacheKey = JSON.stringify({ patterns, base });
+      let files = globCache.get(cacheKey);
+      if (!files) {
+        files = (0, import_tinyglobby.glob)(patterns, {
+          cwd: base
+        });
+        globCache.set(cacheKey, files);
+      }
+      let code = "{";
+      for (const item of await files) {
+        const fullPath = import_node_path.default.join(base, item);
+        const searchParams = new URLSearchParams();
+        for (const [k, v] of Object.entries(query)) {
+          searchParams.set(k, v);
+        }
+        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
+        if (eager) {
+          const name = `__fd_glob_${eagerImportId++}`;
+          this.lines.unshift(
+            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+          );
+          code += `${JSON.stringify(item)}: ${name}, `;
+        } else {
+          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+          if (importName) {
+            line += `.then(mod => mod.${importName})`;
+          }
+          code += `${line}, `;
+        }
+      }
+      code += "}";
+      return code;
+    },
+    formatImportPath(file) {
+      const ext = import_node_path.default.extname(file);
+      let filename;
+      if (ext === ".ts" && 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;
+      }
+      const importPath = slash(import_node_path.default.relative(outDir, filename));
+      return importPath.startsWith(".") ? importPath : `./${importPath}`;
+    },
+    toString() {
+      return [...banner, ...this.lines].join("\n");
+    }
+  };
+}
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function slash(path4) {
+  const isExtendedLengthPath = path4.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path4;
+  }
+  return path4.replaceAll("\\", "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+// src/plugins/index-file.ts
+var import_tinyglobby2 = require("tinyglobby");
+
+// src/utils/fs-cache.ts
+var import_lru_cache = require("lru-cache");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var map = new import_lru_cache.LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (import_node_path2.default.isAbsolute(file)) {
+    return import_node_path2.default.relative(process.cwd(), file);
+  }
+  return file;
+}
+function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+// src/plugins/index-file.ts
+var import_crypto = require("crypto");
+
+// src/utils/fuma-matter.ts
+var import_js_yaml = require("js-yaml");
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = (0, import_js_yaml.load)(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+// src/plugins/index-file.ts
+function indexFile(options = {}) {
+  const {
+    target = "default",
+    addJsExtension,
+    browser = true,
+    dynamic = true
+  } = options;
+  let config;
+  let dynamicCollections;
+  function isDynamic(collection) {
+    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
+  }
+  function generateConfigs(core) {
+    const serverOptions = {};
+    const typeConfigs = [];
+    const ctx = core.getPluginContext();
+    for (const plugin of core.getPlugins()) {
+      const indexFilePlugin = plugin["index-file"];
+      if (!indexFilePlugin) continue;
+      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
+      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config2) typeConfigs.push(config2);
+    }
+    if (typeConfigs.length === 0) {
+      typeConfigs.push("{ DocData: {} }");
+    }
+    return {
+      serverOptions,
+      tc: typeConfigs.join(" & ")
+    };
+  }
+  return {
+    name: "index-file",
+    config(v) {
+      config = v;
+      dynamicCollections = config.collectionList.filter(isDynamic);
+    },
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async (event, file) => {
+        removeFileCache(file);
+        if (dynamicCollections.length === 0) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
+        const updatedCollection = config.collectionList.find(
+          (collection) => collection.hasFile(file)
+        );
+        if (!updatedCollection) return;
+        if (!isDynamic(updatedCollection)) {
+          if (target === "vite") return;
+          if (target === "default" && event === "change") return;
+        }
+        await this.core.emitAndWrite({
+          filterPlugin: (plugin) => plugin.name === "index-file"
+        });
+      });
+    },
+    async emit() {
+      const globCache = /* @__PURE__ */ new Map();
+      const { serverOptions, tc } = generateConfigs(this.core);
+      const toEmitEntry = async (path4, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir: this.outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc
+        });
+        return {
+          path: path4,
+          content: codegen.toString()
+        };
+      };
+      const out = [
+        toEmitEntry("server.ts", generateServerIndexFile)
+      ];
+      if (dynamic)
+        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
+      if (browser)
+        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
+      return await Promise.all(out);
+    }
+  };
+}
+async function generateServerIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
+  codegen.lines.push(
+    `import { server } from 'fumadocs-mdx/runtime/server';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObject(collection) {
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        if (collection.docs.async) {
+          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
+            generateMetaCollectionGlob(codegen, collection.meta, true),
+            generateDocCollectionFrontmatterGlob(
+              codegen,
+              collection.docs,
+              true
+            ),
+            generateDocCollectionGlob(codegen, collection.docs)
+          ]);
+          return `await create.docsLazy("${collection.name}", "${collection.dir}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
+        }
+        const [metaGlob, docGlob] = await Promise.all([
+          generateMetaCollectionGlob(codegen, collection.meta, true),
+          generateDocCollectionGlob(codegen, collection.docs, true)
+        ]);
+        return `await create.docs("${collection.name}", "${collection.dir}", ${metaGlob}, ${docGlob})`;
+      }
+      case "doc":
+        if (collection.dynamic) return;
+        if (collection.async) {
+          const [headGlob, bodyGlob] = await Promise.all([
+            generateDocCollectionFrontmatterGlob(codegen, collection, true),
+            generateDocCollectionGlob(codegen, collection)
+          ]);
+          return `await create.docLazy("${collection.name}", "${collection.dir}", ${headGlob}, ${bodyGlob})`;
+        }
+        return `await create.doc("${collection.name}", "${collection.dir}", ${await generateDocCollectionGlob(
+          codegen,
+          collection,
+          true
+        )})`;
+      case "meta":
+        return `await create.meta("${collection.name}", "${collection.dir}", ${await generateMetaCollectionGlob(
+          codegen,
+          collection,
+          true
+        )})`;
+    }
+  }
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
+}
+async function generateDynamicIndexFile({
+  core,
+  codegen,
+  serverOptions,
+  tc
+}) {
+  const { configPath } = core.getOptions();
+  codegen.lines.push(
+    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
+    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
+    "",
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(core.getOptions())}, ${JSON.stringify(serverOptions)});`
+  );
+  async function generateCollectionObjectEntry(collection, file) {
+    const fullPath = import_path.default.join(collection.dir, file);
+    const content = await readFileWithCache(fullPath).catch(() => "");
+    const parsed = fumaMatter(content);
+    const data = await core.transformFrontmatter(
+      {
+        collection,
+        filePath: fullPath,
+        source: content
+      },
+      parsed.data
+    );
+    const hash = (0, import_crypto.createHash)("md5").update(content).digest("hex");
+    const infoStr = [
+      // make sure it's included in vercel/nft
+      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
+    ];
+    for (const [k, v] of Object.entries({
+      info: {
+        fullPath,
+        path: file
+      },
+      data,
+      hash
+    })) {
+      infoStr.push(`${k}: ${JSON.stringify(v)}`);
+    }
+    return `{ ${infoStr.join(", ")} }`;
+  }
+  async function generateCollectionObject(parent) {
+    let collection;
+    if (parent.type === "doc") collection = parent;
+    else if (parent.type === "docs") collection = parent.docs;
+    if (!collection || !collection.dynamic) return;
+    const files = await (0, import_tinyglobby2.glob)(collection.patterns, {
+      cwd: collection.dir
+    });
+    const entries = await Promise.all(
+      files.map((file) => generateCollectionObjectEntry(collection, file))
+    );
+    switch (parent.type) {
+      case "docs": {
+        const metaGlob = await generateMetaCollectionGlob(
+          codegen,
+          parent.meta,
+          true
+        );
+        return `await create.docs("${parent.name}", "${parent.dir}", ${metaGlob}, ${entries.join(", ")})`;
+      }
+      case "doc":
+        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
+    }
+  }
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
+}
+async function generateBrowserIndexFile({ core, codegen, tc }) {
+  codegen.lines.push(
+    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
+    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
+    "",
+    `const create = browser<typeof Config, ${tc}>();`
+  );
+  async function generateCollectionObject(collection) {
+    switch (collection.type) {
+      case "docs": {
+        if (collection.docs.dynamic) return;
+        return generateCollectionObject(collection.docs);
+      }
+      case "doc":
+        if (collection.dynamic) return;
+        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(codegen, collection)})`;
+    }
+  }
+  codegen.lines.push("const browserCollections = {");
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return ident(`${collection.name}: ${obj},`);
+    })
+  );
+  codegen.lines.push("};", "export default browserCollections;");
+}
+function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      only: "frontmatter"
+    },
+    import: "frontmatter",
+    base: collection.dir,
+    eager
+  });
+}
+function generateDocCollectionGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name
+    },
+    base: collection.dir,
+    eager
+  });
+}
+function generateMetaCollectionGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name
+    },
+    import: "default",
+    base: collection.dir,
+    eager
+  });
+}

package/dist/plugins/index-file.d.cts

@@ -0,0 +1,14 @@
+export { J as IndexFilePlugin, I as IndexFilePluginOptions, H as default } from '../core-DTuP23zu.cjs';
+import '@mdx-js/mdx';
+import '@standard-schema/spec';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.cjs';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';

package/dist/plugins/index-file.d.ts

@@ -0,0 +1,14 @@
+export { J as IndexFilePlugin, I as IndexFilePluginOptions, H as default } from '../core-B9ZoS6sA.js';
+import '@mdx-js/mdx';
+import '@standard-schema/spec';
+import 'unified';
+import 'fumadocs-core/mdx-plugins';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.js';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';

package/dist/plugins/index-file.js

@@ -0,0 +1,8 @@
+import {
+  indexFile
+} from "../chunk-7UKSZSPY.js";
+import "../chunk-WBIHDYMN.js";
+import "../chunk-VWJKRQZR.js";
+export {
+  indexFile as default
+};

package/dist/plugins/json-schema.d.cts

@@ -1,10 +1,17 @@
-import { i as Plugin } from '../core-DB7TdlyC.cjs';
+import { j as Plugin } from '../core-DTuP23zu.cjs';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
-import 'fumadocs-core/mdx-plugins';
 import 'unified';
+import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.cjs';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
 
 interface JSONSchemaOptions {
     /**

package/dist/plugins/json-schema.d.ts

@@ -1,10 +1,17 @@
-import { i as Plugin } from '../core-DB7TdlyC.js';
+import { j as Plugin } from '../core-B9ZoS6sA.js';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
-import 'fumadocs-core/mdx-plugins';
 import 'unified';
+import 'fumadocs-core/mdx-plugins';
 import 'zod';
 import 'chokidar';
+import 'vfile';
+import 'fumadocs-core/source';
+import '../runtime/types.js';
+import 'fumadocs-core/mdx-plugins/remark-structure';
+import 'fumadocs-core/toc';
+import 'mdast';
+import 'mdx/types';
 
 interface JSONSchemaOptions {
     /**