astro-smart-links 1.0.0 → 1.0.1

package/dist/cli.cjs

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_node_process = __toESM(require("process"), 1);
+var import_commander = require("commander");
+
+// src/core/check.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_rehype_parse = __toESM(require("rehype-parse"), 1);
+var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
+var import_unified = require("unified");
+var import_unist_util_visit = require("unist-util-visit");
+
+// src/core/normalize.ts
+var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+function getScheme(href) {
+  const match = SCHEME_RE.exec(href.trim());
+  return match ? match[0].slice(0, -1).toLowerCase() : void 0;
+}
+function isExternalHref(href) {
+  const trimmed = href.trim();
+  if (trimmed.startsWith("//"))
+    return true;
+  const scheme = getScheme(trimmed);
+  return scheme === "http" || scheme === "https";
+}
+function isIgnoredHref(href) {
+  const trimmed = href.trim();
+  if (!trimmed || trimmed.startsWith("#"))
+    return true;
+  const scheme = getScheme(trimmed);
+  return Boolean(scheme) && scheme !== "http" && scheme !== "https";
+}
+function normalizeBase(base) {
+  if (!base)
+    return "";
+  let normalized = base.trim();
+  if (!normalized.startsWith("/"))
+    normalized = `/${normalized}`;
+  normalized = normalized.replace(/\/+$/, "");
+  return normalized === "/" ? "" : normalized;
+}
+function normalizeRoute(input, base) {
+  let path = (input ?? "").trim();
+  path = path.split(/[?#]/, 1)[0] ?? "";
+  try {
+    path = decodeURI(path);
+  } catch {
+  }
+  const normalizedBase = normalizeBase(base);
+  if (normalizedBase) {
+    if (path === normalizedBase)
+      path = "/";
+    else if (path.startsWith(`${normalizedBase}/`))
+      path = path.slice(normalizedBase.length);
+  }
+  if (!path.startsWith("/"))
+    path = `/${path}`;
+  path = path.replace(/\/{2,}/g, "/");
+  path = path.replace(/\/index(?:\.html)?$/i, "/");
+  if (path.length > 1)
+    path = path.replace(/\/+$/, "");
+  return path || "/";
+}
+function resolveInternalHref(href, pagePath) {
+  const trimmed = href.trim();
+  if (trimmed.startsWith("/"))
+    return normalizeRoute(trimmed);
+  const page = pagePath && pagePath !== "/" ? pagePath : "/index";
+  try {
+    const url = new URL(trimmed, `https://smart-links.local${page}`);
+    return normalizeRoute(url.pathname);
+  } catch {
+    return normalizeRoute(trimmed);
+  }
+}
+function matchesIgnoreList(href, pathname, ignore) {
+  for (const pattern of ignore) {
+    if (typeof pattern === "string") {
+      if (href === pattern || href.startsWith(pattern) || pathname === pattern || pathname?.startsWith(pattern))
+        return true;
+    } else if (pattern.test(href) || (pathname ? pattern.test(pathname) : false)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/classify.ts
+function classifyHref(href, context = {}) {
+  if (isIgnoredHref(href))
+    return { type: "ignored", href };
+  if (isExternalHref(href))
+    return { type: "external", href };
+  const pathname = normalizeRoute(resolveInternalHref(href, context.pagePath), context.base);
+  if (matchesIgnoreList(href, pathname, context.ignore ?? []))
+    return { type: "ignored", href, pathname };
+  if (pathname === "/")
+    return { type: "internal", href, pathname };
+  if (context.routes && !context.routes.has(pathname))
+    return { type: "broken", href, pathname };
+  return { type: "internal", href, pathname };
+}
+
+// src/core/hast.ts
+function addClass(node, className) {
+  if (!className)
+    return;
+  const current = node.properties?.className;
+  const classes = Array.isArray(current) ? [...current] : typeof current === "string" ? current.split(/\s+/).filter(Boolean) : [];
+  if (!classes.includes(className))
+    classes.push(className);
+  node.properties = { ...node.properties, className: classes };
+}
+function removeClass(node, className) {
+  if (!className || !node.properties?.className)
+    return;
+  const current = node.properties.className;
+  const classes = Array.isArray(current) ? current.filter((cls) => cls !== className) : typeof current === "string" ? current.split(/\s+/).filter((cls) => cls && cls !== className) : [];
+  if (classes.length > 0)
+    node.properties = { ...node.properties, className: classes };
+  else
+    delete node.properties.className;
+}
+
+// src/core/routes.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function scanRoutes(directory, options = {}) {
+  const routes = /* @__PURE__ */ new Set(["/"]);
+  const {
+    includeAllFiles = false,
+    includeFileExtensions = ["html"],
+    base
+  } = options;
+  if (!(0, import_node_fs.existsSync)(directory))
+    return routes;
+  const walk = (currentDir, basePath) => {
+    for (const entry of (0, import_node_fs.readdirSync)(currentDir, { withFileTypes: true })) {
+      const fullPath = (0, import_node_path.join)(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, basePath ? `${basePath}/${entry.name}` : entry.name);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const extension = (0, import_node_path.extname)(entry.name).slice(1).toLowerCase();
+      const included = includeAllFiles || includeFileExtensions.includes(extension);
+      if (!included)
+        continue;
+      let route = basePath ? `${basePath}/${entry.name}` : entry.name;
+      if (extension === "html") {
+        route = route.replace(/\.html$/i, "");
+        route = route.replace(/(?:^|\/)index$/i, "");
+      }
+      routes.add(normalizeRoute(route, base));
+    }
+  };
+  walk(directory, "");
+  return routes;
+}
+function writeRoutesFile(routes, routesFilePath) {
+  const sorted = Array.from(new Set(routes)).sort();
+  (0, import_node_fs.writeFileSync)(routesFilePath, `${JSON.stringify(sorted, null, 2)}
+`);
+}
+
+// src/core/check.ts
+function collectHtmlFiles(directory) {
+  const files = [];
+  const walk = (currentDir) => {
+    for (const entry of (0, import_node_fs2.readdirSync)(currentDir, { withFileTypes: true })) {
+      const fullPath = (0, import_node_path2.join)(currentDir, entry.name);
+      if (entry.isDirectory())
+        walk(fullPath);
+      else if (entry.isFile() && entry.name.endsWith(".html"))
+        files.push(fullPath);
+    }
+  };
+  walk(directory);
+  return files;
+}
+function routeFromHtmlFile(distDir, htmlFile) {
+  let relativePath = (0, import_node_path2.relative)(distDir, htmlFile).replace(/\\/g, "/");
+  relativePath = relativePath.replace(/\.html$/i, "");
+  relativePath = relativePath.replace(/(?:^|\/)index$/i, "");
+  return normalizeRoute(relativePath);
+}
+function checkDirectory(directory, options = {}) {
+  const routes = options.routes ?? scanRoutes(directory, options);
+  const broken = [];
+  let checkedLinks = 0;
+  for (const htmlFile of collectHtmlFiles(directory)) {
+    const source = (0, import_node_fs2.readFileSync)(htmlFile, "utf-8");
+    if (!source.includes("<a"))
+      continue;
+    const processor = (0, import_unified.unified)().use(import_rehype_parse.default).use(import_rehype_stringify.default);
+    const tree = processor.parse(source);
+    const pagePath = routeFromHtmlFile(directory, htmlFile);
+    let changed = false;
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      if (node.tagName !== "a" || !node.properties)
+        return;
+      const href = node.properties.href;
+      if (typeof href !== "string" || href.length === 0)
+        return;
+      const classified = classifyHref(href, {
+        base: options.base,
+        routes,
+        ignore: options.ignore,
+        pagePath
+      });
+      if (classified.type === "ignored")
+        return;
+      checkedLinks++;
+      if (classified.type !== "broken")
+        return;
+      broken.push({ href, pathname: classified.pathname ?? href, sourceFile: htmlFile });
+      if (options.rewrite) {
+        removeClass(node, options.internalLinkClass);
+        addClass(node, options.brokenLinkClass);
+        changed = true;
+      }
+    });
+    if (changed)
+      (0, import_node_fs2.writeFileSync)(htmlFile, processor.stringify(tree));
+  }
+  return { routes, broken, checkedLinks };
+}
+
+// src/report.ts
+function buildReport(input) {
+  const sourceMap = /* @__PURE__ */ new Map();
+  for (const record of input.records) {
+    if (!record.sourceFile)
+      continue;
+    const key = record.pathname ?? record.href;
+    const sources = sourceMap.get(key) ?? /* @__PURE__ */ new Set();
+    sources.add(record.sourceFile);
+    sourceMap.set(key, sources);
+  }
+  const brokenMap = /* @__PURE__ */ new Map();
+  for (const link of input.broken) {
+    const key = link.pathname || link.href;
+    const entry = brokenMap.get(key) ?? { href: link.href, pathname: link.pathname, sources: [] };
+    const sources = new Set(entry.sources);
+    if (link.sourceFile)
+      sources.add(link.sourceFile);
+    for (const source of sourceMap.get(key) ?? [])
+      sources.add(source);
+    entry.sources = Array.from(sources);
+    brokenMap.set(key, entry);
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    routes: input.routeCount,
+    links: {
+      internal: input.records.filter((record) => record.type === "internal").length,
+      external: input.records.filter((record) => record.type === "external").length,
+      broken: brokenMap.size
+    },
+    broken: Array.from(brokenMap.values()).sort((a, b) => a.pathname.localeCompare(b.pathname))
+  };
+}
+function formatReport(report) {
+  const lines = [];
+  lines.push(`Smart links report (${report.generatedAt})`);
+  lines.push(`Routes scanned: ${report.routes}`);
+  lines.push(`Links: ${report.links.internal} internal, ${report.links.external} external, ${report.links.broken} broken`);
+  if (report.broken.length > 0) {
+    lines.push("");
+    lines.push("Broken internal links:");
+    for (const entry of report.broken) {
+      const sources = entry.sources.length > 0 ? ` (found in ${entry.sources.join(", ")})` : "";
+      lines.push(`  ${entry.pathname || entry.href}${sources}`);
+    }
+  }
+  return lines.join("\n");
+}
+function reportToJSON(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+function reportToHTML(report) {
+  const rows = report.broken.map((entry) => `
+        <tr>
+          <td><code>${escapeHtml(entry.pathname || entry.href)}</code></td>
+          <td><code>${escapeHtml(entry.href)}</code></td>
+          <td>${entry.sources.length > 0 ? entry.sources.map((source) => `<code>${escapeHtml(source)}</code>`).join("<br>") : "\u2014"}</td>
+        </tr>`).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>astro-smart-links report</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font-family: ui-sans-serif, system-ui, sans-serif; max-width: 960px; margin: 0 auto; padding: 2rem 1rem; line-height: 1.6; }
+  h1 { font-size: 1.5rem; }
+  table { border-collapse: collapse; width: 100%; }
+  th, td { border: 1px solid color-mix(in oklab, currentColor 20%, transparent); padding: 0.5rem 0.75rem; text-align: left; vertical-align: top; }
+  th { background: color-mix(in oklab, currentColor 8%, transparent); }
+  code { font-size: 0.9em; }
+  .ok { color: #16a34a; font-weight: 600; }
+</style>
+</head>
+<body>
+  <h1>astro-smart-links report</h1>
+  <p>Generated at ${escapeHtml(report.generatedAt)} \xB7 Scanned ${report.routes} routes</p>
+  <p>${report.links.internal} internal \xB7 ${report.links.external} external \xB7 ${report.links.broken} broken</p>
+  ${report.broken.length === 0 ? '<p class="ok">No broken internal links found.</p>' : `<table>
+    <thead><tr><th>Missing route</th><th>Href</th><th>Found in</th></tr></thead>
+    <tbody>${rows}
+    </tbody>
+  </table>`}
+</body>
+</html>
+`;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("astro-smart-links").description("CLI utility for astro-smart-links").version("1.0.1");
+program.command("check", { isDefault: true }).description("Check a build directory for broken internal links").option("-d, --dir <path>", "Build directory path", "./dist").option("-o, --output <path>", "Write the report to a file").option("--format <format>", "Report format: json or html", "json").option("--json", "Print the report to stdout as JSON", false).option("-a, --all", "Treat every file type as a valid route", false).option("-e, --extensions <ext...>", "File extensions to treat as routes", ["html"]).option("--fail-on-broken", "Exit with code 1 when broken links are found", false).option("-q, --quiet", "Only print the summary line", false).action((options) => {
+  const buildDir = (0, import_node_path3.resolve)(import_node_process.default.cwd(), options.dir);
+  const routesFile = options.output ? (0, import_node_path3.resolve)(import_node_process.default.cwd(), options.output) : void 0;
+  if (!(0, import_node_fs3.existsSync)(buildDir)) {
+    console.error(`Error: build directory '${buildDir}' does not exist.`);
+    import_node_process.default.exit(2);
+  }
+  const { routes, broken, checkedLinks } = checkDirectory(buildDir, {
+    includeAllFiles: options.all,
+    includeFileExtensions: options.extensions,
+    rewrite: false,
+    routes: scanRoutes(buildDir, {
+      includeAllFiles: options.all,
+      includeFileExtensions: options.extensions
+    })
+  });
+  const report = buildReport({ records: [], broken, routeCount: routes.size });
+  report.links.broken = broken.length;
+  if (options.json)
+    import_node_process.default.stdout.write(reportToJSON(report));
+  else if (!options.quiet)
+    console.warn(formatReport(report));
+  console.warn(
+    `Checked ${checkedLinks} links across ${routes.size} routes: ${broken.length} broken.`
+  );
+  if (routesFile) {
+    (0, import_node_fs3.writeFileSync)(routesFile, options.format === "html" ? reportToHTML(report) : reportToJSON(report));
+    console.warn(`Report written to ${routesFile}`);
+  }
+  if (options.failOnBroken && broken.length > 0)
+    import_node_process.default.exit(1);
+  import_node_process.default.exit(0);
+});
+program.command("build").description("[deprecated] Generate a routes file from a build directory").option("-d, --dir <path>", "Build directory path", "./dist").option("-o, --output <path>", "Output path for the routes file", "./.smart-links-routes.json").option("-a, --all", "Include all files", false).option("-e, --extensions <ext...>", "File extensions to include", ["html"]).action((options) => {
+  console.warn(
+    "[astro-smart-links] The `build` command is deprecated: the smartLinks() integration no longer needs a routes file."
+  );
+  const buildDir = (0, import_node_path3.resolve)(import_node_process.default.cwd(), options.dir);
+  if (!(0, import_node_fs3.existsSync)(buildDir)) {
+    console.error(`Error: build directory '${buildDir}' does not exist.`);
+    import_node_process.default.exit(2);
+  }
+  const routes = scanRoutes(buildDir, {
+    includeAllFiles: options.all,
+    includeFileExtensions: options.extensions
+  });
+  const routesFile = (0, import_node_path3.resolve)(import_node_process.default.cwd(), options.output);
+  writeRoutesFile(routes, routesFile);
+  console.warn(`Wrote ${routes.size} routes to ${routesFile}`);
+});
+program.parse(import_node_process.default.argv);

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -15,7 +15,7 @@ import { resolve } from "path";
 import process from "process";
 import { Command } from "commander";
 var program = new Command();
-program.name("astro-smart-links").description("CLI utility for astro-smart-links").version("1.0.0");
+program.name("astro-smart-links").description("CLI utility for astro-smart-links").version("1.0.1");
 program.command("check", { isDefault: true }).description("Check a build directory for broken internal links").option("-d, --dir <path>", "Build directory path", "./dist").option("-o, --output <path>", "Write the report to a file").option("--format <format>", "Report format: json or html", "json").option("--json", "Print the report to stdout as JSON", false).option("-a, --all", "Treat every file type as a valid route", false).option("-e, --extensions <ext...>", "File extensions to treat as routes", ["html"]).option("--fail-on-broken", "Exit with code 1 when broken links are found", false).option("-q, --quiet", "Only print the summary line", false).action((options) => {
   const buildDir = resolve(process.cwd(), options.dir);
   const routesFile = options.output ? resolve(process.cwd(), options.output) : void 0;