meodp 0.1.0 → 0.2.1

package/dist/shared/{meodp.a0bcc3e7.cjs → meodp.2b00b0ae.cjs}

@@ -1,187 +1,8 @@
 'use strict';
 
-const promises = require('node:timers/promises');
-const linkinator = require('linkinator');
-const node_os = require('node:os');
 const node_crypto = require('node:crypto');
-const promises$1 = require('node:fs/promises');
+const promises = require('node:fs/promises');
 const path = require('node:path');
-const node_buffer = require('node:buffer');
-const node_util = require('node:util');
-const node_zlib = require('node:zlib');
-const fastXmlParser = require('fast-xml-parser');
-
-function normalizeUrl(value) {
-  const url = new URL(value);
-  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
-    throw new Error("Expected an HTTP(S) URL without embedded credentials");
-  url.hash = "";
-  return url.href;
-}
-function normalizeTargets(input) {
-  if (!Array.isArray(input))
-    throw new TypeError("Input must be an array of URLs or objects with a url field");
-  const seen = /* @__PURE__ */ new Set();
-  return input.map((item, index) => {
-    const value = typeof item === "string" ? { url: item } : item;
-    if (!value || typeof value !== "object" || !("url" in value) || typeof value.url !== "string")
-      throw new TypeError(`Invalid link at index ${index}: expected a url string`);
-    let url;
-    try {
-      url = normalizeUrl(value.url.trim());
-    } catch {
-      throw new TypeError(`Invalid HTTP(S) URL at index ${index}`);
-    }
-    if ("name" in value && value.name !== void 0 && typeof value.name !== "string")
-      throw new TypeError(`Invalid name at index ${index}: expected a string`);
-    return { url, ..."name" in value && typeof value.name === "string" ? { name: value.name } : {} };
-  }).filter((item) => {
-    if (seen.has(item.url))
-      return false;
-    seen.add(item.url);
-    return true;
-  });
-}
-
-function integerOption(value, fallback, name, minimum, maximum) {
-  const result = value ?? fallback;
-  if (!Number.isInteger(result) || result < minimum || result > maximum)
-    throw new RangeError(`${name} must be an integer between ${minimum} and ${maximum}`);
-  return result;
-}
-function normalizeCheckOptions(options) {
-  const concurrency = integerOption(options.concurrency, 5, "concurrency", 1, 100);
-  const timeoutMs = integerOption(options.timeoutMs, 1e4, "timeoutMs", 1, 3e5);
-  const retries = integerOption(options.retries, 1, "retries", 0, 5);
-  const maxRedirects = integerOption(options.maxRedirects, 5, "maxRedirects", 0, 20);
-  const observer = options.observer ?? node_os.hostname();
-  if (!observer.trim())
-    throw new TypeError("observer must not be empty");
-  if (options.previousReport && options.previousReport.observer !== observer)
-    throw new Error("Previous report belongs to another observer; use a separate history file");
-  return { concurrency, timeoutMs, retries, maxRedirects, observer };
-}
-
-function failureDetail(result) {
-  const error = result.failureDetails?.find((item) => item instanceof Error);
-  const parts = [];
-  let current = error;
-  for (let depth = 0; current && typeof current === "object" && depth < 5; depth++) {
-    for (const key of ["name", "code", "message"]) {
-      const value = Reflect.get(current, key);
-      if (typeof value === "string")
-        parts.push(value);
-    }
-    current = "cause" in current ? current.cause : void 0;
-  }
-  const detail = parts.join(": ") || `HTTP ${result.status ?? 0}`;
-  if (/ENOTFOUND|EAI_AGAIN|EAI_FAIL/.test(detail))
-    return { reason: "dns", detail };
-  if (/CERT|TLS|SSL/i.test(detail))
-    return { reason: "tls", detail };
-  if (/timeout|timed out|ETIMEDOUT|UND_ERR_.*TIMEOUT/i.test(detail))
-    return { reason: "timeout", detail };
-  return { reason: result.status ? "http" : "network", detail };
-}
-async function probe(url, timeoutMs, maxRedirects) {
-  const redirects = [];
-  const visited = /* @__PURE__ */ new Set();
-  let current = url;
-  for (; ; ) {
-    visited.add(current);
-    const checker = new linkinator.LinkChecker();
-    const { links } = await checker.check({
-      path: current,
-      recurse: false,
-      concurrency: 1,
-      timeout: timeoutMs,
-      retry: false,
-      retryErrors: false,
-      redirects: "error",
-      linksToSkip: async (candidate) => candidate !== current
-    });
-    const result = links.find((item) => item.url === current && !item.parent);
-    if (!result)
-      throw new Error("The HTTP checker returned no result for the requested URL");
-    const httpStatus = result.status || void 0;
-    const base = { finalUrl: current, httpStatus, redirects };
-    if (httpStatus && [301, 302, 303, 307, 308].includes(httpStatus)) {
-      const response = result.failureDetails?.find((item) => "headers" in item);
-      const location = response && "headers" in response ? response.headers.location : void 0;
-      let next;
-      try {
-        if (!location)
-          throw new Error("Missing redirect location");
-        next = normalizeUrl(new URL(location, current).href);
-      } catch {
-        return { ...base, status: "unavailable", reason: "redirect", detail: "Missing or invalid HTTP(S) redirect destination" };
-      }
-      redirects.push({ url: current, status: httpStatus, location: next });
-      if (visited.has(next) || redirects.length > maxRedirects) {
-        return {
-          ...base,
-          status: "unavailable",
-          reason: "redirect",
-          detail: visited.has(next) ? "Redirect loop" : "Redirect limit exceeded"
-        };
-      }
-      current = next;
-      continue;
-    }
-    if (httpStatus && httpStatus >= 200 && httpStatus < 300)
-      return { ...base, status: "reachable" };
-    if (httpStatus && [401, 403, 429, 451, 999].includes(httpStatus))
-      return { ...base, status: "restricted", reason: "http", detail: `HTTP ${httpStatus}: access requires review` };
-    return { ...base, status: "unavailable", ...failureDetail(result) };
-  }
-}
-async function checkLinks(input, options = {}) {
-  const targets = normalizeTargets(input);
-  const { concurrency, timeoutMs, retries, maxRedirects, observer } = normalizeCheckOptions(options);
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const previous = new Map(options.previousReport?.results.map((item) => [item.url, item]));
-  const results = [];
-  let cursor = 0;
-  await Promise.all(Array.from({ length: Math.min(concurrency, targets.length) }, async () => {
-    while (cursor < targets.length) {
-      const index = cursor++;
-      const target = targets[index];
-      const start = Date.now();
-      let attempts = 0;
-      let observation;
-      do {
-        if (attempts > 0)
-          await promises.setTimeout(500 * 2 ** (attempts - 1));
-        attempts++;
-        observation = await probe(target.url, timeoutMs, maxRedirects);
-      } while (attempts <= retries && observation.status === "unavailable" && observation.reason !== "redirect" && (!observation.httpStatus || observation.httpStatus >= 500));
-      const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const old = previous.get(target.url);
-      const failed = observation.status === "unavailable";
-      const result = {
-        ...target,
-        ...observation,
-        checkedAt,
-        durationMs: Date.now() - start,
-        attempts,
-        consecutiveFailures: failed ? (old?.status === "unavailable" ? old.consecutiveFailures : 0) + 1 : 0,
-        firstFailureAt: failed ? old?.status === "unavailable" ? old.firstFailureAt ?? checkedAt : checkedAt : void 0,
-        lastSuccessAt: observation.status === "reachable" ? checkedAt : old?.lastSuccessAt,
-        changed: Boolean(old && (old.status !== observation.status || old.finalUrl !== observation.finalUrl)),
-        recovered: observation.status === "reachable" && old?.status === "unavailable"
-      };
-      results[index] = result;
-      await options.onResult?.(result);
-    }
-  }));
-  const summary = { total: results.length, reachable: 0, restricted: 0, unavailable: 0, redirected: 0, recovered: 0 };
-  for (const result of results) {
-    summary[result.status]++;
-    summary.redirected += Number(result.redirects.length > 0);
-    summary.recovered += Number(result.recovered);
-  }
-  return { schemaVersion: 1, observer, startedAt, completedAt: (/* @__PURE__ */ new Date()).toISOString(), summary, results };
-}
 
 function parseReport(data) {
   const invalid = (field) => {
@@ -363,27 +184,27 @@ function formatReport(report, format = "markdown") {
   ].join("\n");
 }
 async function writeReports(report, directory) {
-  await promises$1.mkdir(directory, { recursive: true });
+  await promises.mkdir(directory, { recursive: true });
   const paths = { json: path.join(directory, "report.json"), markdown: path.join(directory, "report.md"), html: path.join(directory, "report.html") };
-  await promises$1.writeFile(paths.json, formatReport(report, "json"));
-  await promises$1.writeFile(paths.markdown, formatReport(report, "markdown"));
-  await promises$1.writeFile(paths.html, formatReport(report, "html"));
+  await promises.writeFile(paths.json, formatReport(report, "json"));
+  await promises.writeFile(paths.markdown, formatReport(report, "markdown"));
+  await promises.writeFile(paths.html, formatReport(report, "html"));
   return paths;
 }
 async function writeReportSite(report, directory, options = {}) {
   const html = createReportHtml(report, { dataUrl: report ? "./report.json" : void 0, ...options });
-  await promises$1.mkdir(directory, { recursive: true });
+  await promises.mkdir(directory, { recursive: true });
   const index = path.join(directory, "index.html");
   const json = report ? path.join(directory, "report.json") : void 0;
   if (json)
-    await promises$1.writeFile(json, formatReport(report, "json"));
-  await promises$1.writeFile(index, html);
+    await promises.writeFile(json, formatReport(report, "json"));
+  await promises.writeFile(index, html);
   return { index, json };
 }
 async function readReport(path) {
   let data;
   try {
-    data = JSON.parse(await promises$1.readFile(path, "utf8"));
+    data = JSON.parse(await promises.readFile(path, "utf8"));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return void 0;
@@ -392,189 +213,16 @@ async function readReport(path) {
   return parseReport(data);
 }
 async function saveReport(report, path$1) {
-  await promises$1.mkdir(path.dirname(path$1), { recursive: true });
+  await promises.mkdir(path.dirname(path$1), { recursive: true });
   const temporary = `${path$1}.${node_crypto.randomUUID()}.tmp`;
-  await promises$1.writeFile(temporary, formatReport(report, "json"));
-  await promises$1.rename(temporary, path$1);
-}
-
-const unzip = node_util.promisify(node_zlib.gunzip);
-class DocumentError extends Error {
-  constructor(message, retryable = false) {
-    super(message);
-    this.retryable = retryable;
-  }
-}
-function discoveryOptions(options) {
-  const normalized = normalizeCheckOptions(options);
-  if (options.discover !== void 0 && typeof options.discover !== "boolean")
-    throw new TypeError("discover must be a boolean");
-  return {
-    ...normalized,
-    maxUrls: integerOption(options.maxUrls, 1e4, "maxUrls", 1, 5e4),
-    maxSitemaps: integerOption(options.maxSitemaps, 100, "maxSitemaps", 1, 1e4),
-    maxSitemapBytes: integerOption(options.maxSitemapBytes, 10 * 1024 * 1024, "maxSitemapBytes", 1, 100 * 1024 * 1024)
-  };
-}
-async function readDocument(source, options, allowMissing = false) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      let url = source;
-      const visited = /* @__PURE__ */ new Set();
-      for (; ; ) {
-        visited.add(url);
-        const response = await fetch(url, {
-          redirect: "manual",
-          signal: AbortSignal.timeout(options.timeoutMs)
-        });
-        if ([301, 302, 303, 307, 308].includes(response.status)) {
-          await response.body?.cancel();
-          const location = response.headers.get("location");
-          let next;
-          try {
-            if (!location)
-              throw new Error("Missing location");
-            next = normalizeUrl(new URL(location, url).href);
-          } catch {
-            throw new DocumentError(`Invalid sitemap/robots redirect from ${url}`);
-          }
-          if (visited.has(next) || visited.size > options.maxRedirects)
-            throw new DocumentError(`Sitemap/robots redirect loop or limit exceeded: ${url}`);
-          url = next;
-          continue;
-        }
-        if (!response.ok) {
-          await response.body?.cancel();
-          if (allowMissing && [404, 410].includes(response.status))
-            return void 0;
-          throw new DocumentError(`Unable to read ${url}: HTTP ${response.status}`, response.status >= 500);
-        }
-        const chunks = [];
-        let size = 0;
-        if (response.body) {
-          const reader = response.body.getReader();
-          try {
-            for (; ; ) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              size += value.byteLength;
-              if (size > options.maxSitemapBytes)
-                throw new DocumentError(`Discovery document exceeds maxSitemapBytes: ${url}`);
-              chunks.push(value);
-            }
-          } finally {
-            await reader.cancel().catch(() => {
-            });
-            reader.releaseLock();
-          }
-        }
-        let body = node_buffer.Buffer.concat(chunks);
-        if (body[0] === 31 && body[1] === 139) {
-          try {
-            body = await unzip(body, { maxOutputLength: options.maxSitemapBytes });
-          } catch {
-            throw new DocumentError(`Invalid gzip or decompressed document exceeds maxSitemapBytes: ${url}`);
-          }
-        }
-        return { url, text: body.toString("utf8") };
-      }
-    } catch (error) {
-      if (attempt >= options.retries || error instanceof DocumentError && !error.retryable)
-        throw new Error(`Sitemap discovery failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-      await promises.setTimeout(500 * 2 ** attempt);
-    }
-  }
-}
-function parseLocations(text, source) {
-  if (/<!DOCTYPE|<!ENTITY/i.test(text) || fastXmlParser.XMLValidator.validate(text) !== true)
-    throw new Error(`Invalid sitemap XML: ${source}`);
-  const parser = new fastXmlParser.XMLParser({
-    ignoreAttributes: true,
-    removeNSPrefix: true,
-    parseTagValue: false,
-    isArray: (name) => name === "url" || name === "sitemap"
-  });
-  const document = parser.parse(text);
-  const roots = Object.keys(document).filter((key) => !key.startsWith("?"));
-  if (roots.length !== 1 || !["urlset", "sitemapindex"].includes(roots[0]))
-    throw new Error(`Expected a sitemap urlset or sitemapindex: ${source}`);
-  const isIndex = roots[0] === "sitemapindex";
-  const root = document[roots[0]];
-  if (root?.[isIndex ? "url" : "sitemap"])
-    throw new Error(`Mixed sitemap index and page entries: ${source}`);
-  const entries = root?.[isIndex ? "sitemap" : "url"] ?? [];
-  const urls = entries.map((entry) => {
-    if (!entry || typeof entry !== "object" || !("loc" in entry) || typeof entry.loc !== "string" || !entry.loc.trim())
-      throw new Error(`Missing or invalid sitemap loc: ${source}`);
-    try {
-      return normalizeUrl(new URL(entry.loc.trim(), source).href);
-    } catch {
-      throw new Error(`Invalid HTTP(S) URL in sitemap: ${source}`);
-    }
-  });
-  return { isIndex, urls };
-}
-async function readSitemapUrls(source, options = {}) {
-  const input = normalizeUrl(source.trim());
-  const config = discoveryOptions(options);
-  let pending = [input];
-  if (options.discover) {
-    const robots = await readDocument(new URL("/robots.txt", input).href, config, true);
-    const declared = robots?.text.split(/\r?\n/).flatMap((line) => {
-      const match = line.match(/^\s*sitemap\s*:\s*(\S+)/i);
-      return match ? [normalizeUrl(new URL(match[1], robots.url).href)] : [];
-    }) ?? [];
-    pending = declared.length ? declared : [new URL("/sitemap.xml", input).href];
-  }
-  const queued = new Set(pending);
-  pending = [...queued];
-  const visited = /* @__PURE__ */ new Set();
-  const pages = /* @__PURE__ */ new Set();
-  let documentCount = 0;
-  for (let cursor = 0; cursor < pending.length; cursor++) {
-    const url = pending[cursor];
-    if (visited.has(url))
-      continue;
-    if (++documentCount > config.maxSitemaps)
-      throw new Error("Sitemap discovery exceeds maxSitemaps; no pages were checked");
-    visited.add(url);
-    const document = await readDocument(url, config);
-    if (!document)
-      throw new Error(`Unable to read sitemap: ${url}`);
-    visited.add(document.url);
-    const { isIndex, urls } = parseLocations(document.text, document.url);
-    for (const location of urls) {
-      if (isIndex) {
-        if (!queued.has(location) && !visited.has(location)) {
-          queued.add(location);
-          pending.push(location);
-        }
-      } else {
-        pages.add(location);
-        if (pages.size > config.maxUrls)
-          throw new Error("Sitemap discovery exceeds maxUrls; no pages were checked");
-      }
-    }
-  }
-  if (!pages.size)
-    throw new Error("Sitemap discovery found no page URLs; no pages were checked");
-  return [...pages];
-}
-async function checkSitemap(source, options = {}) {
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const urls = await readSitemapUrls(source, options);
-  const report = await checkLinks(urls, options);
-  return { ...report, startedAt };
+  await promises.writeFile(temporary, formatReport(report, "json"));
+  await promises.rename(temporary, path$1);
 }
 
-exports.checkLinks = checkLinks;
-exports.checkSitemap = checkSitemap;
+exports.createReportHtml = createReportHtml;
 exports.formatReport = formatReport;
-exports.normalizeTargets = normalizeTargets;
 exports.parseReport = parseReport;
 exports.readReport = readReport;
-exports.readSitemapUrls = readSitemapUrls;
 exports.saveReport = saveReport;
 exports.writeReportSite = writeReportSite;
 exports.writeReports = writeReports;

package/dist/shared/meodp.4f1da070.d.cts

@@ -0,0 +1,41 @@
+import { C as CheckReport } from './meodp.93e06e00.cjs';
+
+interface ReportSiteOptions {
+    /** Automatically load this HTTP(S) or relative JSON URL when hosted. */
+    dataUrl?: string;
+}
+
+type ReporterName = 'json' | 'markdown' | 'html';
+type HtmlReporterOptions = ReportSiteOptions & ({
+    outputFolder?: string;
+    outputFile?: never;
+} | {
+    outputFile: string;
+    outputFolder?: never;
+});
+type ReporterDescription = ReporterName | readonly ['json' | 'markdown', {
+    outputFile?: string;
+}?] | readonly ['html', HtmlReporterOptions?];
+/** A name, a list of names, or a list of [name, options] tuples. */
+type ReporterConfig = ReporterName | readonly ReporterDescription[];
+interface ReporterOutput {
+    reporter: ReporterName;
+    files: string[];
+}
+interface ReporterOptions extends ReportSiteOptions {
+    /** Default directory for reporters without explicit output paths. */
+    outputDir?: string;
+    /** Resolve relative output paths from this directory (default: working directory). */
+    cwd?: string;
+}
+/** Run built-in reporters on saved data; no network requests or browser launch. */
+declare function writeReporters(report: CheckReport | undefined, reporter: ReporterConfig, options?: ReporterOptions): Promise<ReporterOutput[]>;
+
+interface ReportVerificationOptions {
+    url: string;
+    attempts?: number;
+    delayMs?: number;
+}
+declare function waitForReport(expected: CheckReport, { url, attempts, delayMs }: ReportVerificationOptions): Promise<void>;
+
+export { type HtmlReporterOptions as H, type ReporterConfig as R, type ReportVerificationOptions as a, type ReportSiteOptions as b, type ReporterDescription as c, type ReporterName as d, type ReporterOptions as e, type ReporterOutput as f, waitForReport as g, writeReporters as w };

package/dist/shared/meodp.63483e20.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('node:path');
+const process = require('node:process');
+const c12 = require('c12');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+async function loadProjectConfig(file) {
+  if (file)
+    await promises.access(path.resolve(file));
+  const { config, configFile } = await c12.loadConfig({
+    name: "meodp",
+    cwd: process__default.cwd(),
+    configFile: file ? path.resolve(file) : void 0,
+    rcFile: false,
+    globalRc: false,
+    dotenv: false,
+    packageJson: false,
+    extend: false,
+    giget: false
+  });
+  const root = configFile ? path.dirname(configFile) : process__default.cwd();
+  return { config, path: (value) => path.resolve(root, value) };
+}
+
+exports.loadProjectConfig = loadProjectConfig;