fumadocs-mdx 14.2.2 → 14.2.4

package/dist/chunk-2PY3JUIC.js

@@ -1,126 +0,0 @@
-// src/utils/codegen.ts
-import path from "path";
-import { glob } from "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(path.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 = glob(patterns, {
-          cwd: base
-        });
-        globCache.set(cacheKey, files);
-      }
-      let code = "{";
-      for (const item of await files) {
-        const fullPath = path.join(base, item);
-        const searchParams = new URLSearchParams();
-        for (const [k, v] of Object.entries(query)) {
-          if (v !== void 0) 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 = path.extname(file);
-      let filename;
-      if (ext === ".ts") {
-        filename = file.substring(0, file.length - ext.length);
-        if (jsExtension) filename += ".js";
-      } else {
-        filename = file;
-      }
-      const importPath = slash(path.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(path2) {
-  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path2;
-  }
-  return path2.replaceAll("\\", "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
-
-export {
-  createCodegen,
-  slash,
-  ident
-};

package/dist/chunk-4EUH5CD2.js

@@ -1,173 +0,0 @@
-import {
-  flattenNode,
-  remarkInclude
-} from "./chunk-WFDF56IJ.js";
-
-// src/loaders/mdx/build-mdx.ts
-import { createProcessor } from "@mdx-js/mdx";
-import { VFile } from "vfile";
-
-// 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,
-  extractLinkReferences = false,
-  valueToExport = []
-}) {
-  let _stringifyProcessor;
-  const getStringifyProcessor = () => {
-    return _stringifyProcessor ??= _format === "mdx" ? this : (
-      // force Markdown processor to stringify MDX nodes
-      this().use(remarkMdx).freeze()
-    );
-  };
-  return (tree, file) => {
-    const frontmatter = file.data.frontmatter ??= {};
-    if (!frontmatter.title) {
-      visit(tree, "heading", (node) => {
-        if (node.depth === 1) {
-          frontmatter.title = flattenNode(node);
-          return false;
-        }
-      });
-    }
-    file.data["mdx-export"] ??= [];
-    file.data["mdx-export"].push({
-      name: "frontmatter",
-      value: frontmatter
-    });
-    if (extractLinkReferences) {
-      const urls = [];
-      visit(tree, "link", (node) => {
-        urls.push({
-          href: node.url
-        });
-        return "skip";
-      });
-      file.data["mdx-export"].push({
-        name: "extractedReferences",
-        value: urls
-      });
-    }
-    if (includeProcessedMarkdown) {
-      const processor = getStringifyProcessor();
-      const markdown = toMarkdown(tree, {
-        ...processor.data("settings"),
-        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
-        extensions: processor.data("toMarkdownExtensions") || []
-      });
-      file.data["mdx-export"].push({
-        name: "_markdown",
-        value: markdown
-      });
-    }
-    if (includeMDAST) {
-      const options = includeMDAST === true ? {} : includeMDAST;
-      const mdast = JSON.stringify(
-        options.removePosition ? removePosition(structuredClone(tree)) : tree
-      );
-      file.data["mdx-export"].push({
-        name: "_mdast",
-        value: mdast
-      });
-    }
-    for (const { name, value } of file.data["mdx-export"]) {
-      tree.children.unshift(getMdastExport(name, value));
-    }
-    file.data["mdx-export"] = [];
-    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)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-
-// src/loaders/mdx/build-mdx.ts
-async function buildMDX(core, collection, {
-  filePath,
-  frontmatter,
-  source,
-  _compiler,
-  environment,
-  isDevelopment
-}) {
-  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
-  function getProcessor(format) {
-    const cache = core.cache;
-    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
-    let processor = cache.get(key);
-    if (!processor) {
-      const postprocessOptions = {
-        _format: format,
-        ...collection?.postprocess
-      };
-      processor = createProcessor({
-        outputFormat: "program",
-        development: isDevelopment,
-        ...mdxOptions,
-        remarkPlugins: [
-          remarkInclude,
-          ...mdxOptions.remarkPlugins ?? [],
-          [remarkPostprocess, postprocessOptions]
-        ],
-        format
-      });
-      cache.set(key, processor);
-    }
-    return processor;
-  }
-  let vfile = new VFile({
-    value: source,
-    path: filePath,
-    cwd: collection?.cwd,
-    data: { frontmatter, _compiler, _getProcessor: getProcessor }
-  });
-  if (collection) {
-    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
-  }
-  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
-}
-
-export {
-  buildMDX
-};

package/dist/chunk-4JSFLXXT.js

@@ -1,8 +0,0 @@
-// src/loaders/index.ts
-var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
-var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
-
-export {
-  metaLoaderGlob,
-  mdxLoaderGlob
-};

package/dist/chunk-5OBUOALK.js

@@ -1,141 +0,0 @@
-// src/runtime/server.ts
-import * as path from "path";
-function server(options = {}) {
-  const { doc: { passthroughs: docPassthroughs = [] } = {} } = options;
-  function fileInfo(file, base) {
-    if (file.startsWith("./")) {
-      file = file.slice(2);
-    }
-    return {
-      path: file,
-      fullPath: path.join(base, file)
-    };
-  }
-  function mapDocData(entry) {
-    const data = {
-      body: entry.default,
-      toc: entry.toc,
-      structuredData: entry.structuredData,
-      _exports: entry
-    };
-    for (const key of docPassthroughs) {
-      data[key] = entry[key];
-    }
-    return data;
-  }
-  return {
-    async doc(_name, base, glob) {
-      const out = await Promise.all(
-        Object.entries(glob).map(async ([k, v]) => {
-          const data = typeof v === "function" ? await v() : v;
-          return {
-            ...mapDocData(data),
-            ...data.frontmatter,
-            ...createDocMethods(fileInfo(k, base), () => data)
-          };
-        })
-      );
-      return out;
-    },
-    async docLazy(_name, base, head, body) {
-      const out = await Promise.all(
-        Object.entries(head).map(async ([k, v]) => {
-          const data = typeof v === "function" ? await v() : v;
-          const content = body[k];
-          return {
-            ...data,
-            ...createDocMethods(fileInfo(k, base), content),
-            async load() {
-              return mapDocData(await content());
-            }
-          };
-        })
-      );
-      return out;
-    },
-    async meta(_name, base, glob) {
-      const out = await Promise.all(
-        Object.entries(glob).map(async ([k, v]) => {
-          const data = typeof v === "function" ? await v() : v;
-          return {
-            info: fileInfo(k, base),
-            ...data
-          };
-        })
-      );
-      return out;
-    },
-    async docs(name, base, metaGlob, docGlob) {
-      const entry = {
-        docs: await this.doc(name, base, docGlob),
-        meta: await this.meta(name, base, metaGlob),
-        toFumadocsSource() {
-          return toFumadocsSource(this.docs, this.meta);
-        }
-      };
-      return entry;
-    },
-    async docsLazy(name, base, metaGlob, docHeadGlob, docBodyGlob) {
-      const entry = {
-        docs: await this.docLazy(name, base, docHeadGlob, docBodyGlob),
-        meta: await this.meta(name, base, metaGlob),
-        toFumadocsSource() {
-          return toFumadocsSource(this.docs, this.meta);
-        }
-      };
-      return entry;
-    }
-  };
-}
-function toFumadocsSource(pages, metas) {
-  const files = [];
-  for (const entry of pages) {
-    files.push({
-      type: "page",
-      path: entry.info.path,
-      absolutePath: entry.info.fullPath,
-      data: entry
-    });
-  }
-  for (const entry of metas) {
-    files.push({
-      type: "meta",
-      path: entry.info.path,
-      absolutePath: entry.info.fullPath,
-      data: entry
-    });
-  }
-  return {
-    files
-  };
-}
-function createDocMethods(info, load) {
-  return {
-    info,
-    async getText(type) {
-      if (type === "raw") {
-        const fs = await import("fs/promises");
-        return (await fs.readFile(info.fullPath)).toString();
-      }
-      const data = await load();
-      if (typeof data._markdown !== "string")
-        throw new Error(
-          "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
-        );
-      return data._markdown;
-    },
-    async getMDAST() {
-      const data = await load();
-      if (!data._mdast)
-        throw new Error(
-          "getMDAST() requires `includeMDAST` to be enabled in your collection config."
-        );
-      return JSON.parse(data._mdast);
-    }
-  };
-}
-
-export {
-  server,
-  toFumadocsSource
-};

package/dist/chunk-DTFUANSF.js

@@ -1,40 +0,0 @@
-import {
-  buildConfig
-} from "./chunk-OLD35ARB.js";
-
-// src/config/load-from-file.ts
-import { pathToFileURL } from "url";
-async function compileConfig(core) {
-  const { build } = await import("esbuild");
-  const { configPath, outDir } = core.getOptions();
-  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(core, build = false) {
-  if (build) await compileConfig(core);
-  const url = pathToFileURL(core.getCompiledConfigPath());
-  url.searchParams.set("hash", Date.now().toString());
-  const config = import(url.href).then(
-    (loaded) => buildConfig(loaded)
-  );
-  return await config;
-}
-
-export {
-  loadConfig
-};