@hanzo/docs-mdx 14.1.1 → 14.2.4

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-72JS4QVZ.js

@@ -1,17 +0,0 @@
-import {
-  createCore
-} from "./chunk-UB55AMXC.js";
-
-// src/webpack/index.ts
-var core;
-function getCore(options) {
-  return core ??= createCore({
-    environment: "webpack",
-    outDir: options.outDir,
-    configPath: options.configPath
-  });
-}
-
-export {
-  getCore
-};

package/dist/chunk-7I4W7XGI.js

@@ -1,179 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-UB55AMXC.js";
-
-// src/loaders/adapter.ts
-import { fileURLToPath } from "url";
-import fs from "fs/promises";
-import { parse } from "querystring";
-import path from "path";
-import { readFileSync } from "fs";
-function toNode(loader) {
-  return async (url, _context, nextLoad) => {
-    if (url.startsWith("file:///") && (!loader.test || loader.test.test(url))) {
-      const parsedUrl = new URL(url);
-      const filePath = fileURLToPath(parsedUrl);
-      const result = await loader.load({
-        filePath,
-        query: Object.fromEntries(parsedUrl.searchParams.entries()),
-        async getSource() {
-          return (await fs.readFile(filePath)).toString();
-        },
-        development: false,
-        compiler: {
-          addDependency() {
-          }
-        }
-      });
-      if (result) {
-        return {
-          source: result.code,
-          format: "module",
-          shortCircuit: true
-        };
-      }
-    }
-    return nextLoad(url);
-  };
-}
-function toVite(loader) {
-  return {
-    filter(id) {
-      return !loader.test || loader.test.test(id);
-    },
-    async transform(value, id) {
-      const [file, query = ""] = id.split("?", 2);
-      const result = await loader.load({
-        filePath: file,
-        query: parse(query),
-        getSource() {
-          return value;
-        },
-        development: this.environment.mode === "dev",
-        compiler: {
-          addDependency: (file2) => {
-            this.addWatchFile(file2);
-          }
-        }
-      });
-      if (result === null) return null;
-      return {
-        code: result.code,
-        map: result.map
-      };
-    }
-  };
-}
-function toWebpack(loader) {
-  return async function(source, callback) {
-    try {
-      const result = await loader.load({
-        filePath: this.resourcePath,
-        query: 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 = path.relative(this.context, this.resourcePath);
-      error.message = `${fpath}:${error.name}: ${error.message}`;
-      callback(error);
-    }
-  };
-}
-function toBun(loader) {
-  function toResult(output) {
-    if (!output) return;
-    return {
-      contents: output.code,
-      loader: "js"
-    };
-  }
-  return (build) => {
-    build.onLoad({ filter: loader.test ?? /.+/ }, (args) => {
-      const [filePath, query = ""] = args.path.split("?", 2);
-      const input = {
-        async getSource() {
-          return Bun.file(filePath).text();
-        },
-        query: parse(query),
-        filePath,
-        development: false,
-        compiler: {
-          addDependency() {
-          }
-        }
-      };
-      if (loader.bun?.load) {
-        return loader.bun.load(readFileSync(filePath).toString(), input);
-      }
-      const result = loader.load(input);
-      if (result instanceof Promise) {
-        return result.then(toResult);
-      }
-      return toResult(result);
-    });
-  };
-}
-
-// src/loaders/config.ts
-import fs2 from "fs/promises";
-function createStandaloneConfigLoader({
-  core,
-  buildConfig,
-  mode
-}) {
-  let prev;
-  async function getConfigHash() {
-    if (mode === "production") return "static";
-    const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
-      throw new Error("Cannot find config file");
-    });
-    return stats.mtime.getTime().toString();
-  }
-  return {
-    async getCore() {
-      const hash = await getConfigHash();
-      if (!prev || hash !== prev.hash) {
-        prev = {
-          hash,
-          init: (async () => {
-            const { loadConfig } = await import("./load-from-file-S5CQ4H6T.js");
-            await core.init({
-              config: loadConfig(core, buildConfig)
-            });
-          })()
-        };
-      }
-      await prev.init;
-      return core;
-    }
-  };
-}
-function createIntegratedConfigLoader(core) {
-  return {
-    async getCore() {
-      return core;
-    }
-  };
-}
-
-export {
-  toNode,
-  toVite,
-  toWebpack,
-  toBun,
-  createStandaloneConfigLoader,
-  createIntegratedConfigLoader
-};

package/dist/chunk-7W73RILB.js

@@ -1,173 +0,0 @@
-import {
-  flattenNode,
-  remarkInclude
-} from "./chunk-Y7ISNZ7X.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
-};