fumadocs-mdx 14.0.1 → 14.0.2

package/dist/webpack/mdx.d.cts

@@ -1,20 +0,0 @@
-import { LoaderContext } from 'webpack';
-import { W as WebpackLoaderOptions } from '../index-BD8Woo4m.cjs';
-import '../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';
-
-declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string, callback: LoaderContext<WebpackLoaderOptions>['callback']): Promise<void>;
-
-export { loader as default };

package/dist/webpack/meta.cjs

@@ -1,684 +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 __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/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,
-          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
-    };
-  };
-}
-var init_preset = __esm({
-  "src/config/preset.ts"() {
-    "use strict";
-  }
-});
-
-// src/config/build.ts
-function buildCollection(name, config) {
-  if (config.type === "docs") {
-    return {
-      ...config,
-      name,
-      meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs),
-      hasFile(filePath) {
-        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
-      }
-    };
-  }
-  return buildPrimitiveCollection(name, config);
-}
-function buildPrimitiveCollection(name, { files, ...config }) {
-  const supportedFormats = SupportedFormats[config.type];
-  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matchers;
-  return {
-    ...config,
-    name,
-    patterns,
-    isFileSupported(filePath) {
-      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
-    },
-    hasFile(filePath) {
-      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
-        (dir) => (0, import_picomatch.default)(patterns, {
-          cwd: dir
-        })
-      );
-      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
-    }
-  };
-}
-function buildConfig(config) {
-  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") {
-        collections.set(k, buildCollection(k, v));
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(
-          k,
-          buildCollection(k, v)
-        );
-        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,
-    collectionList: Array.from(collections.values()),
-    getCollection(name) {
-      return collections.get(name);
-    },
-    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;
-    }
-  };
-}
-var import_picomatch, SupportedFormats;
-var init_build = __esm({
-  "src/config/build.ts"() {
-    "use strict";
-    import_picomatch = __toESM(require("picomatch"), 1);
-    init_preset();
-    SupportedFormats = {
-      doc: ["mdx", "md"],
-      meta: ["json", "yaml"]
-    };
-  }
-});
-
-// src/config/load-from-file.ts
-var load_from_file_exports = {};
-__export(load_from_file_exports, {
-  loadConfig: () => loadConfig
-});
-async function compileConfig(core2) {
-  const { build } = await import("esbuild");
-  const { configPath, outDir } = core2.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(core2, build = false) {
-  if (build) await compileConfig(core2);
-  const url = (0, import_node_url2.pathToFileURL)(core2.getCompiledConfigPath());
-  url.searchParams.set("hash", Date.now().toString());
-  const config = import(url.href).then(
-    (loaded) => buildConfig(loaded)
-  );
-  return await config;
-}
-var import_node_url2;
-var init_load_from_file = __esm({
-  "src/config/load-from-file.ts"() {
-    "use strict";
-    import_node_url2 = require("url");
-    init_build();
-  }
-});
-
-// src/webpack/meta.ts
-var meta_exports = {};
-__export(meta_exports, {
-  default: () => loader
-});
-module.exports = __toCommonJS(meta_exports);
-
-// src/loaders/adapter.ts
-var import_node_url = require("url");
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_querystring = require("querystring");
-
-// 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 picocolors = await import("picocolors");
-    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/loaders/adapter.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_node_fs = require("fs");
-function toWebpack(loader2) {
-  return async function(source, callback) {
-    try {
-      const result = await loader2.load({
-        filePath: this.resourcePath,
-        query: (0, import_node_querystring.parse)(this.resourceQuery.slice(1)),
-        getSource() {
-          return source;
-        },
-        development: this.mode === "development",
-        compiler: this
-      });
-      if (result === null) {
-        callback(void 0, source);
-      } else {
-        callback(void 0, result.code, result.map);
-      }
-    } catch (error) {
-      if (error instanceof ValidationError) {
-        return callback(new Error(await error.toStringFormatted()));
-      }
-      if (!(error instanceof Error)) throw error;
-      const fpath = import_node_path.default.relative(this.context, this.resourcePath);
-      error.message = `${fpath}:${error.name}: ${error.message}`;
-      callback(error);
-    }
-  };
-}
-
-// src/loaders/config.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-function createStandaloneConfigLoader({
-  core: core2,
-  buildConfig: buildConfig2,
-  mode
-}) {
-  let loaded;
-  async function getConfigHash() {
-    if (mode === "production") return "static";
-    const stats = await import_promises2.default.stat(core2.getOptions().configPath).catch(() => {
-      throw new Error("Cannot find config file");
-    });
-    return stats.mtime.getTime().toString();
-  }
-  async function newConfig() {
-    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
-    await core2.init({
-      config: loadConfig2(core2, buildConfig2)
-    });
-    return core2.getConfig();
-  }
-  return {
-    core: core2,
-    async getConfig() {
-      const hash = await getConfigHash();
-      if (loaded && loaded.hash === hash) return loaded.config;
-      loaded = {
-        hash,
-        config: newConfig()
-      };
-      return loaded.config;
-    }
-  };
-}
-
-// src/loaders/meta.ts
-var import_js_yaml = require("js-yaml");
-var import_zod = require("zod");
-
-// src/loaders/index.ts
-var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
-
-// src/loaders/meta.ts
-var querySchema = import_zod.z.object({
-  collection: import_zod.z.string().optional()
-}).loose();
-function createMetaLoader(configLoader, resolve = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
-  function parse2(filePath, source) {
-    try {
-      if (filePath.endsWith(".json")) return JSON.parse(source);
-      if (filePath.endsWith(".yaml")) return (0, import_js_yaml.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 collectionName = parsed.data.collection;
-    return async () => {
-      const config = await configLoader.getConfig();
-      const collection = config.getCollection(collectionName);
-      let metaCollection;
-      switch (collection?.type) {
-        case "meta":
-          metaCollection = collection;
-          break;
-        case "docs":
-          metaCollection = collection.meta;
-          break;
-      }
-      const data = parse2(filePath, source);
-      if (!metaCollection) return data;
-      return configLoader.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 {
-          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
-        };
-      } else {
-        return {
-          code: resolveYaml === "yaml" ? (0, import_js_yaml.dump)(data) : `export default ${JSON.stringify(data)}`
-        };
-      }
-    },
-    bun: {
-      load(source, input) {
-        const result = onMeta(source, input);
-        if (result === null)
-          return {
-            loader: "object",
-            exports: parse2(input.filePath, source)
-          };
-        return result().then((data) => ({
-          loader: "object",
-          exports: { default: data }
-        }));
-      }
-    }
-  };
-}
-
-// src/core.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var import_promises3 = __toESM(require("fs/promises"), 1);
-
-// src/utils/codegen.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_tinyglobby = require("tinyglobby");
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
-
-// src/core.ts
-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, defaultPlugins = []) {
-  let config;
-  let plugins;
-  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;
-  }
-  const core2 = {
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      plugins = await getPlugins([
-        postprocessPlugin(),
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
-      ]);
-      for (const plugin of plugins) {
-        const out = await plugin.config?.call(pluginContext, config);
-        if (out) config = out;
-      }
-    },
-    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 import_node_path3.default.join(options.outDir, "source.config.mjs");
-    },
-    getPlugins() {
-      return plugins;
-    },
-    getPluginContext() {
-      return pluginContext;
-    },
-    async initServer(server) {
-      for (const plugin of plugins) {
-        await plugin.configureServer?.call(pluginContext, server);
-      }
-    },
-    async emit({ filterPlugin = () => true } = {}) {
-      return (await Promise.all(
-        plugins.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(pluginContext);
-        })
-      )).flat();
-    },
-    async emitAndWrite(emitOptions) {
-      const start = performance.now();
-      const out = await this.emit(emitOptions);
-      await Promise.all(
-        out.map(async (entry) => {
-          const file = import_node_path3.default.join(options.outDir, entry.path);
-          await import_promises3.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
-          await import_promises3.default.writeFile(file, entry.content);
-        })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
-    },
-    async transformMeta(options2, data) {
-      const ctx = {
-        ...pluginContext,
-        ...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 = {
-        ...pluginContext,
-        ...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 = {
-        ...pluginContext,
-        ...options2
-      };
-      for (const plugin of plugins) {
-        if (plugin.doc?.vfile)
-          file = await plugin.doc.vfile.call(ctx, file) ?? file;
-      }
-      return file;
-    }
-  };
-  const pluginContext = {
-    core: core2,
-    ...options
-  };
-  return core2;
-}
-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.getConfig().collectionList) {
-          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");
-      }
-    }
-  };
-}
-
-// src/webpack/index.ts
-var core;
-function getCore(options) {
-  return core ??= createCore({
-    environment: "webpack",
-    outDir: options.outDir,
-    configPath: options.configPath
-  });
-}
-
-// src/webpack/meta.ts
-var instance;
-async function loader(source, callback) {
-  const options = this.getOptions();
-  this.cacheable(true);
-  this.addDependency(options.compiledConfigPath);
-  if (!instance) {
-    instance = toWebpack(
-      createMetaLoader(
-        createStandaloneConfigLoader({
-          core: getCore(options),
-          buildConfig: false,
-          mode: options.isDev ? "dev" : "production"
-        }),
-        {
-          json: "json",
-          yaml: "js"
-        }
-      )
-    );
-  }
-  await instance.call(this, source, callback);
-}