saturndocs 0.1.0

package/dist/chunk-J6P3VGGE.js

@@ -0,0 +1,21 @@
+// src/lib/table.ts
+function renderTable(headers, rows) {
+  const columnCount = headers.length;
+  const widths = headers.map((header, columnIndex) => {
+    let width = header.length;
+    for (const row of rows) {
+      const cell = row[columnIndex] ?? "";
+      if (cell.length > width) width = cell.length;
+    }
+    return width;
+  });
+  const padRow = (cells) => cells.map(
+    (cell, columnIndex) => columnIndex === columnCount - 1 ? cell : cell.padEnd(widths[columnIndex] ?? 0)
+  ).join("  ").trimEnd();
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+  return [padRow(headers), divider, ...rows.map(padRow)].join("\n");
+}
+
+export {
+  renderTable
+};

package/dist/chunk-KGJESHJC.js

@@ -0,0 +1,37 @@
+import {
+  EXIT,
+  failureResult,
+  interrupted
+} from "./chunk-GYRVGWDM.js";
+
+// src/adapter/signals.ts
+var active = null;
+function interruptSignal() {
+  return active;
+}
+function installInterrupt(options) {
+  const source = options.source ?? process;
+  const exit = options.exit ?? ((code) => process.exit(code));
+  const controller = new AbortController();
+  const handler = () => {
+    controller.abort(interrupted());
+    const context = options.context();
+    options.writer.write(failureResult(interrupted(), context));
+    source.off("SIGINT", handler);
+    exit(EXIT.interrupted);
+  };
+  source.on("SIGINT", handler);
+  active = controller.signal;
+  return {
+    signal: controller.signal,
+    dispose() {
+      if (active === controller.signal) active = null;
+      source.off("SIGINT", handler);
+    }
+  };
+}
+
+export {
+  interruptSignal,
+  installInterrupt
+};

package/dist/chunk-M2BZEDAS.js

@@ -0,0 +1,57 @@
+// src/adapter/help.ts
+var GLOBAL_LONGS = /* @__PURE__ */ new Set(["--json", "--site", "--api", "--input", "--no-input", "--timeout"]);
+function syntaxOf(flag) {
+  if (flag.value === "boolean") return flag.name;
+  const placeholder = flag.value === "integer" ? "n" : flag.name.replace(/^--/u, "");
+  return `${flag.name} <${placeholder}>`;
+}
+function textLine(metadata) {
+  const { requirement, limit, sources } = metadata.text;
+  if (requirement === "none") return null;
+  const cap = limit === null ? "" : `, at most ${limit} characters`;
+  return `Text (${requirement}): ${sources.join(", ")}${cap}.`;
+}
+function permissionLine(metadata) {
+  const server = metadata.permissions.server ?? "none";
+  const preflight = metadata.permissions.preflight;
+  return preflight === null ? `Permission: ${server}.` : `Permission: ${server}, after a ${preflight} check that the credential names --site.`;
+}
+function targetLine(metadata) {
+  if (metadata.target.site === "required") return "Target: --site is required and must match the credential's site.";
+  if (metadata.target.site === "inferred") return "Target: --site is optional; the credential's own site is used.";
+  return "Target: no site. Nothing leaves this process.";
+}
+function helpBody(metadata) {
+  const lines = [
+    "",
+    metadata.description,
+    "",
+    targetLine(metadata),
+    permissionLine(metadata),
+    textLine(metadata),
+    `Side effects: ${metadata.side_effects.effect}`,
+    `Exit codes: ${metadata.exits.join(", ")}.`,
+    "",
+    "Examples:",
+    ...metadata.examples.map((example) => `  ${example.command}
+      ${example.description}`),
+    ""
+  ];
+  return lines.filter((line) => line !== null).join("\n");
+}
+function applyCommandHelp(command, metadata) {
+  command.description(metadata.summary);
+  const declared = new Set(command.options.map((option) => option.long));
+  for (const flag of metadata.flags) {
+    if (GLOBAL_LONGS.has(flag.name) || declared.has(flag.name)) continue;
+    if (flag.required) command.requiredOption(syntaxOf(flag), flag.description);
+    else command.option(syntaxOf(flag), flag.description);
+  }
+  command.addHelpText("after", helpBody(metadata));
+  return command;
+}
+
+export {
+  helpBody,
+  applyCommandHelp
+};

package/dist/chunk-N7QPZMLP.js

@@ -0,0 +1,82 @@
+import {
+  invalidInput
+} from "./chunk-GYRVGWDM.js";
+
+// src/adapter/input.ts
+import { readFile } from "fs/promises";
+var STDIN_BYTE_CEILING = 1048576;
+function countCodePoints(text) {
+  return Array.from(text).length;
+}
+async function readStdin(source, byteCeiling, command) {
+  if (source.isTTY === true) {
+    throw invalidInput(`${command} was told to read the text from stdin, but stdin is a terminal. Pipe the text in, or use --text or --file <path>.`);
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  for await (const chunk of source) {
+    const buffer = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+    bytes += buffer.byteLength;
+    if (bytes > byteCeiling) {
+      throw invalidInput(`${command} read more than ${byteCeiling} bytes from stdin. Nothing was sent.`);
+    }
+    text += decoder.decode(buffer, { stream: true });
+  }
+  return text + decoder.decode();
+}
+async function readTextInput(flags, options) {
+  const { command, requirement, limit } = options;
+  const given = [flags.text === void 0 ? null : "--text", flags.file === void 0 ? null : "--file"].filter(
+    (name) => name !== null
+  );
+  if (requirement === "none" && given.length > 0) {
+    throw invalidInput(`${command} takes no text, and ${given.join(" and ")} was given.`);
+  }
+  if (given.length > 1) {
+    throw invalidInput(`${command} takes exactly one of --text or --file. Both were given.`);
+  }
+  if (given.length === 0) {
+    if (requirement === "required") {
+      throw invalidInput(`${command} needs text. Pass --text <text>, --file <path>, or --file - to read stdin.`);
+    }
+    return null;
+  }
+  const byteCeiling = limit === null ? STDIN_BYTE_CEILING : Math.min(STDIN_BYTE_CEILING, limit * 4 + 1);
+  let text;
+  if (flags.text !== void 0) {
+    text = flags.text;
+  } else if (flags.file === "-") {
+    const stdin = options.stdin ?? process.stdin;
+    if (options.interactive === false && stdin.isTTY === true) {
+      throw invalidInput(`${command} cannot read stdin under --no-input from a terminal.`);
+    }
+    text = await readStdin(stdin, byteCeiling, command);
+  } else {
+    const path = flags.file;
+    const read = options.readFileImpl ?? ((target) => readFile(target, "utf8"));
+    try {
+      text = await read(path);
+    } catch (error) {
+      throw invalidInput(`${command} could not read ${path}: ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error
+      });
+    }
+  }
+  if (text.trim() === "") {
+    if (requirement === "required") throw invalidInput(`${command} was given empty text.`);
+    return null;
+  }
+  if (limit !== null) {
+    const size = countCodePoints(text);
+    if (size > limit) {
+      throw invalidInput(`${command} accepts at most ${limit} characters and was given ${size}. Nothing was sent.`);
+    }
+  }
+  return text;
+}
+
+export {
+  STDIN_BYTE_CEILING,
+  readTextInput
+};

package/dist/chunk-OEAEX5YW.js

@@ -0,0 +1,51 @@
+// src/lib/links.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, extname, join, relative } from "path";
+import fg from "fast-glob";
+function isInternalLink(href) {
+  if (href === "") return false;
+  if (href.startsWith("#")) return false;
+  if (href.startsWith("//")) return false;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(href)) return false;
+  return true;
+}
+function candidatePaths(distDir, htmlFile, href) {
+  const path = href.split("#")[0].split("?")[0];
+  if (path === "") return [];
+  const base = path.startsWith("/") ? join(distDir, path) : join(dirname(htmlFile), path);
+  if (path.endsWith("/")) {
+    return [join(base, "index.html")];
+  }
+  if (extname(base) !== "") {
+    return [base];
+  }
+  return [base, `${base}.html`, join(base, "index.html")];
+}
+async function scanBrokenLinks(distDir) {
+  const htmlFiles = await fg("**/*.html", { cwd: distDir, absolute: true });
+  const attrRe = /(?:href|src)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+  const seen = /* @__PURE__ */ new Set();
+  const misses = [];
+  for (const htmlFile of htmlFiles) {
+    const html = await readFile(htmlFile, "utf8");
+    const source = relative(distDir, htmlFile);
+    let match;
+    while ((match = attrRe.exec(html)) !== null) {
+      const href = (match[1] ?? match[2] ?? "").trim();
+      if (!isInternalLink(href)) continue;
+      const candidates = candidatePaths(distDir, htmlFile, href);
+      if (candidates.length === 0) continue;
+      if (candidates.some((candidate) => existsSync(candidate))) continue;
+      const key = `${source}\0${href}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      misses.push({ source, href });
+    }
+  }
+  return misses;
+}
+
+export {
+  scanBrokenLinks
+};