@hanzo/docs-mdx 14.1.0

package/dist/chunk-VKSHE52K.js

@@ -0,0 +1,274 @@
+import {
+  ident
+} from "./chunk-PW2AZGGD.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-VWJKRQZR.js

@@ -0,0 +1,19 @@
+// src/utils/fuma-matter.ts
+import { load } from "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 = load(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+export {
+  fumaMatter
+};

package/dist/chunk-WAAWFNDX.js

@@ -0,0 +1,179 @@
+import {
+  ValidationError
+} from "./chunk-VKSHE52K.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-FHW724YY.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-WGXYJGSZ.js

@@ -0,0 +1,141 @@
+// 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),
+        toDocsSource() {
+          return toDocsSource(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),
+        toDocsSource() {
+          return toDocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toDocsSource(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,
+  toDocsSource
+};

package/dist/chunk-WLJ6EKOZ.js

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