fumadocs-mdx 14.2.3 → 14.2.5

package/dist/chunk-KWSETXYC.js

@@ -1,274 +0,0 @@
-import {
-  ident
-} from "./chunk-2PY3JUIC.js";
-
-// src/utils/validation.ts
-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;
-  }
-  async toStringFormatted() {
-    const picocolorsModule = await import("picocolors");
-    const picocolors = picocolorsModule.default ?? picocolorsModule;
-    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 path from "path";
-import fs from "fs/promises";
-var _Defaults = {
-  configPath: "source.config.ts",
-  outDir: ".source"
-};
-async function getPlugins(pluginOptions) {
-  const plugins = [];
-  for await (const option of pluginOptions) {
-    if (!option) continue;
-    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
-    else plugins.push(option);
-  }
-  return plugins;
-}
-function createCore(options) {
-  let config;
-  let plugins;
-  const workspaces = /* @__PURE__ */ new Map();
-  async function transformMetadata({
-    collection,
-    filePath,
-    source
-  }, data) {
-    if (collection.schema) {
-      data = await validate(
-        collection.schema,
-        data,
-        { path: filePath, source },
-        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
-      );
-    }
-    return data;
-  }
-  return {
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      workspaces.clear();
-      plugins = await getPlugins([
-        postprocessPlugin(),
-        options.plugins,
-        config.global.plugins
-      ]);
-      for (const plugin of plugins) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
-        if (out) config = out;
-      }
-      if (!options.workspace) {
-        await Promise.all(
-          Object.entries(config.workspaces).map(async ([name, workspace]) => {
-            const core = createCore({
-              ...options,
-              outDir: path.join(options.outDir, name),
-              workspace: {
-                name,
-                parent: this,
-                dir: workspace.dir
-              }
-            });
-            await core.init({ config: workspace.config });
-            workspaces.set(name, core);
-          })
-        );
-      }
-    },
-    getWorkspaces() {
-      return workspaces;
-    },
-    getOptions() {
-      return options;
-    },
-    getConfig() {
-      return config;
-    },
-    /**
-     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
-     */
-    getCompiledConfigPath() {
-      return path.join(options.outDir, "source.config.mjs");
-    },
-    getPlugins() {
-      return plugins;
-    },
-    getCollections() {
-      return Array.from(config.collections.values());
-    },
-    getCollection(name) {
-      return config.collections.get(name);
-    },
-    getPluginContext() {
-      return {
-        core: this
-      };
-    },
-    async initServer(server) {
-      const ctx = this.getPluginContext();
-      for (const plugin of plugins) {
-        await plugin.configureServer?.call(ctx, server);
-      }
-      for (const workspace of workspaces.values()) {
-        await workspace.initServer(server);
-      }
-    },
-    async emit(emitOptions = {}) {
-      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
-      const start = performance.now();
-      const ctx = this.getPluginContext();
-      const added = /* @__PURE__ */ new Set();
-      const out = {
-        entries: [],
-        workspaces: {}
-      };
-      for (const li of await Promise.all(
-        plugins.map((plugin) => {
-          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
-          return plugin.emit.call(ctx);
-        })
-      )) {
-        if (!li) continue;
-        for (const item of li) {
-          if (added.has(item.path)) continue;
-          out.entries.push(item);
-          added.add(item.path);
-        }
-      }
-      if (write) {
-        await Promise.all(
-          out.entries.map(async (entry) => {
-            const file = path.join(options.outDir, entry.path);
-            await fs.mkdir(path.dirname(file), { recursive: true });
-            await fs.writeFile(file, entry.content);
-          })
-        );
-        console.log(
-          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
-        );
-      }
-      for (const [name, workspace] of workspaces) {
-        if (filterWorkspace && !filterWorkspace(name)) continue;
-        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
-      }
-      return out;
-    },
-    async transformMeta(options2, data) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      data = await transformMetadata(options2, data);
-      for (const plugin of plugins) {
-        if (plugin.meta?.transform)
-          data = await plugin.meta.transform.call(ctx, data) ?? data;
-      }
-      return data;
-    },
-    async transformFrontmatter(options2, data) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      data = await transformMetadata(options2, data);
-      for (const plugin of plugins) {
-        if (plugin.doc?.frontmatter)
-          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
-      }
-      return data;
-    },
-    async transformVFile(options2, file) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      for (const plugin of plugins) {
-        if (plugin.doc?.vfile)
-          file = await plugin.doc.vfile.call(ctx, file) ?? file;
-      }
-      return file;
-    }
-  };
-}
-function postprocessPlugin() {
-  const LinkReferenceTypes = `{
-  /**
-   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
-   */
-  extractedReferences: import("fumadocs-mdx").ExtractedReference[];
-}`;
-  return {
-    "index-file": {
-      generateTypeConfig() {
-        const lines = [];
-        lines.push("{");
-        lines.push("  DocData: {");
-        for (const collection of this.core.getCollections()) {
-          let postprocessOptions;
-          switch (collection.type) {
-            case "doc":
-              postprocessOptions = collection.postprocess;
-              break;
-            case "docs":
-              postprocessOptions = collection.docs.postprocess;
-              break;
-          }
-          if (postprocessOptions?.extractLinkReferences) {
-            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
-          }
-        }
-        lines.push("  }");
-        lines.push("}");
-        return lines.join("\n");
-      },
-      serverOptions(options) {
-        options.doc ??= {};
-        options.doc.passthroughs ??= [];
-        options.doc.passthroughs.push("extractedReferences");
-      }
-    }
-  };
-}
-
-export {
-  ValidationError,
-  _Defaults,
-  createCore
-};

package/dist/chunk-OLD35ARB.js

@@ -1,116 +0,0 @@
-import {
-  applyMdxPreset
-} from "./chunk-S7KOJHHO.js";
-
-// src/config/build.ts
-import picomatch from "picomatch";
-import path from "path";
-var SupportedFormats = {
-  doc: ["mdx", "md"],
-  meta: ["json", "yaml"]
-};
-function buildCollection(name, collection, cwd) {
-  if (collection.type === "docs") {
-    return {
-      ...collection,
-      type: "docs",
-      get dir() {
-        return this.docs.dir;
-      },
-      name,
-      meta: buildCollection(name, collection.meta, cwd),
-      docs: buildCollection(name, collection.docs, cwd),
-      hasFile(filePath) {
-        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
-      },
-      isFileSupported(filePath) {
-        return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
-      },
-      cwd
-    };
-  }
-  return {
-    ...collection,
-    ...buildPrimitiveCollection(name, collection, cwd)
-  };
-}
-function buildPrimitiveCollection(name, config, cwd) {
-  const supportedFormats = SupportedFormats[config.type];
-  const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matcher;
-  return {
-    dir: path.resolve(cwd, config.dir),
-    cwd,
-    name,
-    patterns,
-    isFileSupported(filePath) {
-      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
-    },
-    hasFile(filePath) {
-      if (!this.isFileSupported(filePath)) return false;
-      const relativePath = path.relative(this.dir, filePath);
-      if (relativePath.startsWith(`..${path.sep}`)) return false;
-      return (matcher ??= picomatch(patterns))(relativePath);
-    }
-  };
-}
-function buildConfig(config, cwd = process.cwd()) {
-  const collections = /* @__PURE__ */ new Map();
-  const loaded = {};
-  for (const [k, v] of Object.entries(config)) {
-    if (!v) {
-      continue;
-    }
-    if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs" || v.type === "doc" || v.type === "meta") {
-        collections.set(k, buildCollection(k, v, cwd));
-        continue;
-      }
-    }
-    if (k === "default" && v) {
-      Object.assign(loaded, v);
-      continue;
-    }
-    throw new Error(
-      `Unknown export "${k}", you can only export collections from source configuration file.`
-    );
-  }
-  const mdxOptionsCache = /* @__PURE__ */ new Map();
-  return {
-    global: loaded,
-    collections,
-    workspaces: Object.fromEntries(
-      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
-        return [
-          key,
-          {
-            dir: value.dir,
-            config: buildConfig(value.config, path.resolve(cwd, value.dir))
-          }
-        ];
-      })
-    ),
-    getMDXOptions(collection, environment = "bundler") {
-      const key = collection ? `${environment}:${collection.name}` : environment;
-      const cached = mdxOptionsCache.get(key);
-      if (cached) return cached;
-      let result;
-      if (collection?.mdxOptions) {
-        const optionsFn = collection.mdxOptions;
-        result = typeof optionsFn === "function" ? optionsFn(environment) : optionsFn;
-      } else {
-        result = (async () => {
-          const optionsFn = this.global.mdxOptions;
-          const options = typeof optionsFn === "function" ? await optionsFn() : optionsFn;
-          return applyMdxPreset(options)(environment);
-        })();
-      }
-      mdxOptionsCache.set(key, result);
-      return result;
-    }
-  };
-}
-
-export {
-  buildConfig
-};

package/dist/chunk-RSASAHLX.js

@@ -1,91 +0,0 @@
-import {
-  metaLoaderGlob
-} from "./chunk-4JSFLXXT.js";
-
-// src/loaders/meta.ts
-import { load } from "js-yaml";
-import { z } from "zod";
-var querySchema = z.object({
-  collection: z.string().optional(),
-  workspace: z.string().optional()
-}).loose();
-function createMetaLoader({ getCore }, resolve = {}) {
-  const { json: resolveJson = "js" } = resolve;
-  function parse(filePath, source) {
-    try {
-      if (filePath.endsWith(".json")) return JSON.parse(source);
-      if (filePath.endsWith(".yaml")) return load(source);
-    } catch (e) {
-      throw new Error(`invalid data in ${filePath}`, { cause: e });
-    }
-    throw new Error("Unknown file type " + filePath);
-  }
-  function onMeta(source, { filePath, query }) {
-    const parsed = querySchema.safeParse(query);
-    if (!parsed.success || !parsed.data.collection) return null;
-    const { collection: collectionName, workspace } = parsed.data;
-    return async () => {
-      let core = await getCore();
-      if (workspace) {
-        core = core.getWorkspaces().get(workspace) ?? core;
-      }
-      const collection = core.getCollection(collectionName);
-      let metaCollection;
-      switch (collection?.type) {
-        case "meta":
-          metaCollection = collection;
-          break;
-        case "docs":
-          metaCollection = collection.meta;
-          break;
-      }
-      const data = parse(filePath, source);
-      if (!metaCollection) return data;
-      return core.transformMeta(
-        {
-          collection: metaCollection,
-          filePath,
-          source
-        },
-        data
-      );
-    };
-  }
-  return {
-    test: metaLoaderGlob,
-    async load(input) {
-      const result = onMeta(await input.getSource(), input);
-      if (result === null) return null;
-      const data = await result();
-      if (input.filePath.endsWith(".json")) {
-        return {
-          moduleType: resolveJson,
-          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
-        };
-      } else {
-        return {
-          moduleType: "js",
-          code: `export default ${JSON.stringify(data)}`
-        };
-      }
-    },
-    bun: {
-      load(source, input) {
-        const result = onMeta(source, input);
-        if (result === null)
-          return {
-            loader: "object",
-            exports: parse(input.filePath, source)
-          };
-        return result().then((data) => ({
-          loader: "object",
-          exports: { default: data }
-        }));
-      }
-    }
-  };
-}
-
-export {
-  createMetaLoader
-};

package/dist/chunk-S7KOJHHO.js

@@ -1,89 +0,0 @@
-// src/config/preset.ts
-function pluginOption(def, options = []) {
-  const list = def(Array.isArray(options) ? options : []).filter(
-    Boolean
-  );
-  if (typeof options === "function") {
-    return options(list);
-  }
-  return list;
-}
-function applyMdxPreset(options = {}) {
-  return async (environment = "bundler") => {
-    if (options.preset === "minimal") return options;
-    const plugins = await import("fumadocs-core/mdx-plugins");
-    const {
-      valueToExport = [],
-      rehypeCodeOptions,
-      remarkImageOptions,
-      remarkHeadingOptions,
-      remarkStructureOptions,
-      remarkCodeTabOptions,
-      remarkNpmOptions,
-      ...mdxOptions
-    } = options;
-    const remarkPlugins = pluginOption(
-      (v) => [
-        plugins.remarkGfm,
-        [
-          plugins.remarkHeading,
-          {
-            generateToc: false,
-            ...remarkHeadingOptions
-          }
-        ],
-        remarkImageOptions !== false && [
-          plugins.remarkImage,
-          {
-            ...remarkImageOptions,
-            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
-          }
-        ],
-        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
-          plugins.remarkCodeTab,
-          remarkCodeTabOptions
-        ],
-        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
-        ...v,
-        remarkStructureOptions !== false && [
-          plugins.remarkStructure,
-          {
-            exportAs: "structuredData",
-            ...remarkStructureOptions
-          }
-        ],
-        valueToExport.length > 0 && (() => {
-          return (_, file) => {
-            file.data["mdx-export"] ??= [];
-            for (const name of valueToExport) {
-              if (!(name in file.data)) continue;
-              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: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
-      remarkPlugins,
-      rehypePlugins
-    };
-  };
-}
-
-export {
-  applyMdxPreset
-};