fumadocs-mdx 14.0.1 → 14.0.3

package/dist/node/loader.d.cts

@@ -1,5 +0,0 @@
-import { LoadHook } from 'node:module';
-
-declare const load: LoadHook;
-
-export { load };

package/dist/plugins/index-file.cjs

@@ -1,495 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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/json-schema.cjs

@@ -1,114 +0,0 @@
-"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/json-schema.ts
-var json_schema_exports = {};
-__export(json_schema_exports, {
-  default: () => jsonSchema
-});
-module.exports = __toCommonJS(json_schema_exports);
-var import_zod = require("zod");
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path = __toESM(require("path"), 1);
-function jsonSchema({
-  insert = false
-} = {}) {
-  let config;
-  function getSchemaPath(name) {
-    return `json-schema/${name}.json`;
-  }
-  return {
-    config(v) {
-      config = v;
-    },
-    configureServer(server) {
-      if (!server.watcher || !insert) return;
-      server.watcher.on("add", async (file) => {
-        let parent;
-        let match;
-        for (const collection of config.collectionList) {
-          if (collection.type === "meta" && collection.hasFile(file)) {
-            match = collection;
-            break;
-          }
-          if (collection.type === "docs" && collection.meta.hasFile(file)) {
-            parent = collection;
-            match = collection.meta;
-            break;
-          }
-        }
-        if (!match) return;
-        let obj;
-        try {
-          const content = (await import_promises.default.readFile(file)).toString();
-          obj = content.length > 0 ? JSON.parse(content) : {};
-        } catch {
-          return;
-        }
-        if ("$schema" in obj) return;
-        const schemaPath = import_node_path.default.join(
-          this.outDir,
-          getSchemaPath(parent ? `${parent.name}.meta` : match.name)
-        );
-        const updated = {
-          $schema: import_node_path.default.relative(import_node_path.default.dirname(file), schemaPath),
-          ...obj
-        };
-        await import_promises.default.writeFile(file, JSON.stringify(updated, null, 2));
-      });
-    },
-    emit() {
-      const files = [];
-      function onSchema(name, schema) {
-        files.push({
-          path: getSchemaPath(name),
-          content: JSON.stringify(
-            import_zod.z.toJSONSchema(schema, {
-              io: "input",
-              unrepresentable: "any"
-            })
-          )
-        });
-      }
-      for (const collection of config.collectionList) {
-        if (collection.type === "docs") {
-          if (collection.meta.schema instanceof import_zod.z.ZodType) {
-            onSchema(`${collection.name}.meta`, collection.meta.schema);
-          }
-          if (collection.docs.schema instanceof import_zod.z.ZodType) {
-            onSchema(`${collection.name}.docs`, collection.docs.schema);
-          }
-        } else if (collection.schema instanceof import_zod.z.ZodType) {
-          onSchema(collection.name, collection.schema);
-        }
-      }
-      return files;
-    }
-  };
-}

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

@@ -1,31 +0,0 @@
-import { j as Plugin } 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';
-
-interface JSONSchemaOptions {
-    /**
-     * insert `$schema` field to JSON files on creation.
-     *
-     * @defaultValue false
-     */
-    insert?: boolean;
-}
-/**
- * Generate JSON schemas locally for collection schemas
- *
- * note: **it only works with Zod**
- */
-declare function jsonSchema({ insert, }?: JSONSchemaOptions): Plugin;
-
-export { type JSONSchemaOptions, jsonSchema as default };