@dukebot/astro-html-validator 1.1.0 → 1.1.2

package/README.md

@@ -46,6 +46,8 @@ astro-html-validator [selector] [options]
 
 Options:
   --dir <path>      Path to the dist directory (default: <cwd>/dist)
+  --links-absolute-prefixes <list>
+                    Comma-separated absolute URL prefixes treated as local routes
   --quiet           Disable summary output
   --help            Show help
 ```
@@ -67,7 +69,9 @@ const validator = new Validator({
       disallowEmptyInLanguage: true,
       requireLangMatch: true,
     },
-    links: {},
+    links: {
+      absoluteUrlPrefixes: ['https://example.com', 'https://www.example.com'],
+    },
     meta: {
       metaTitleMinLength: 30,
       metaTitleMaxLength: 60,
@@ -82,6 +86,17 @@ const results = await validator.run({ selector: 'all' });
 console.log(results);
 ```
 
+### Internal links: absolute-to-local prefix mapping
+
+The `links` validator can treat some absolute URLs as local internal routes.
+
+If `absoluteUrlPrefixes` contains your site domains, links like:
+
+- `https://example.com/about`
+- `https://www.example.com/contact?utm=x#team`
+
+are normalized to local paths (`/about`, `/contact`) and validated against `dist`.
+
 ### Architecture (current)
 
 - `src/index.mjs` exports the coordinator class (`Validator`) that orchestrates all checks.
@@ -143,3 +158,4 @@ Quick steps:
 
 
 
+

package/bin/cli.mjs

@@ -18,6 +18,8 @@ Selector:
 
 Options:
   --dir <path>      Path to the dist directory (default: ./dist)
+  --links-absolute-prefixes <list>
+                    Comma-separated absolute URL prefixes treated as local
   --quiet           Disable printed summary output
   --help            Show help
 
@@ -25,6 +27,7 @@ Examples:
   astro-html-validator
   astro-html-validator meta
   astro-html-validator links --dir ./dist
+  astro-html-validator links --links-absolute-prefixes https://example.com,https://www.example.com
   astro-html-validator jsonld,meta
 `);
 }
@@ -36,6 +39,7 @@ function parseArgs(argv = process.argv.slice(2)) {
   const options = {
     selector: 'all',
     dirPath: path.resolve(process.cwd(), 'dist'),
+    linksAbsolutePrefixes: [],
     print: true,
     help: false,
   };
@@ -67,6 +71,17 @@ function parseArgs(argv = process.argv.slice(2)) {
       continue;
     }
 
+    if (arg === '--links-absolute-prefixes') {
+      const next = argv[index + 1];
+      if (!next) throw new Error('Missing value for --links-absolute-prefixes');
+      options.linksAbsolutePrefixes = next
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+      index += 1;
+      continue;
+    }
+
     throw new Error(`Unknown argument: ${arg}`);
   }
 
@@ -88,7 +103,11 @@ async function main() {
 
   const validator = new Validator({
     dirPath: parsed.dirPath,
-    config: {},
+    config: {
+      links: {
+        absoluteUrlPrefixes: parsed.linksAbsolutePrefixes,
+      },
+    },
     print: parsed.print,
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dukebot/astro-html-validator",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Validate Astro-generated HTML output for SEO metadata, JSON-LD, and internal links.",
   "type": "module",
   "main": "./src/index.mjs",

package/src/utils/links.mjs

@@ -1,35 +1,92 @@
 import path from 'node:path';
 import { pathExists } from './common.mjs';
 
+/**
+ * Normalizes configured absolute URL prefixes.
+ */
+function normalizeAbsolutePrefixes(absoluteUrlPrefixes = []) {
+  if (!absoluteUrlPrefixes) return [];
+
+  const values = Array.isArray(absoluteUrlPrefixes)
+    ? absoluteUrlPrefixes
+    : String(absoluteUrlPrefixes)
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+
+  return [...new Set(values.map((value) => value.replace(/\/+$/, '')))];
+}
+
+/**
+ * Converts a matching absolute URL into a local root-relative URL.
+ */
+function toLocalPathFromAbsolute(rawUrl, absolutePrefixes) {
+  for (const prefix of absolutePrefixes) {
+    if (rawUrl === prefix) return '/';
+    if (rawUrl.startsWith(`${prefix}/`)) return rawUrl.slice(prefix.length);
+  }
+
+  return null;
+}
+
+/**
+ * Removes non-rendered sections to avoid false positives when extracting links.
+ */
+function sanitizeHtmlForLinkExtraction(html = '') {
+  if (!html) return '';
+
+  return html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+    .replace(/<style\b[\s\S]*?<\/style>/gi, '');
+}
+
 /**
  * Extracts local (root-relative) URLs from href/src attributes.
  */
-export function extractInternalUrls(html) {
+export function extractInternalUrls(html, { absoluteUrlPrefixes = [] } = {}) {
   const urls = new Set();
-  const regex = /(?:href|src)=["']([^"']+)["']/gi;
-
-  let match;
-  while ((match = regex.exec(html)) !== null) {
-    const raw = match[1]?.trim();
-    if (!raw) continue;
-
-    if (
-      raw.startsWith('http://') ||
-      raw.startsWith('https://') ||
-      raw.startsWith('//') ||
-      raw.startsWith('#') ||
-      raw.startsWith('mailto:') ||
-      raw.startsWith('tel:') ||
-      raw.startsWith('javascript:') ||
-      raw.startsWith('data:')
-    ) {
-      continue;
-    }
+  const tagRegex = /<[^>]+>/g;
+  const attrRegex = /\b(?:href|src)\s*=\s*["']([^"']+)["']/gi;
+  const absolutePrefixes = normalizeAbsolutePrefixes(absoluteUrlPrefixes);
+  const safeHtml = sanitizeHtmlForLinkExtraction(html);
 
-    if (raw.startsWith('/')) {
-      const clean = raw.split('#')[0].split('?')[0];
-      if (clean) urls.add(clean);
+  let tagMatch;
+  while ((tagMatch = tagRegex.exec(safeHtml)) !== null) {
+    const tag = tagMatch[0];
+    if (!tag || tag.startsWith('</')) continue;
+
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(tag)) !== null) {
+      const raw = attrMatch[1]?.trim();
+      if (!raw) continue;
+
+      if (
+        raw.startsWith('//') ||
+        raw.startsWith('#') ||
+        raw.startsWith('mailto:') ||
+        raw.startsWith('tel:') ||
+        raw.startsWith('javascript:') ||
+        raw.startsWith('data:')
+      ) {
+        continue;
+      }
+
+      const clean = raw.split(/[?#]/)[0];
+      if (!clean) continue;
+
+      if (clean.startsWith('/')) {
+        urls.add(clean);
+        continue;
+      }
+
+      if (clean.startsWith('http://') || clean.startsWith('https://')) {
+        const localPath = toLocalPathFromAbsolute(clean, absolutePrefixes);
+        if (localPath) urls.add(localPath);
+      }
     }
+
+    attrRegex.lastIndex = 0;
   }
 
   return [...urls];

package/src/validators/links.mjs

@@ -9,13 +9,13 @@ export class LinksValidator extends Validator {
    * Initializes link validator configuration (reserved for future rules).
    */
   constructor({
-    // Reserved for future options.
+    absoluteUrlPrefixes = [],
   } = {}) {
     super({
       name: 'links',
       label: 'Internal links',
       config: {
-        // Reserved for future options.
+        absoluteUrlPrefixes,
       },
     });
   }
@@ -25,7 +25,9 @@ export class LinksValidator extends Validator {
    */
   async validatePage({ html, dirPath }) {
     const pageWarnings = [];
-    const urls = extractInternalUrls(html);
+    const urls = extractInternalUrls(html, {
+      absoluteUrlPrefixes: this.config.absoluteUrlPrefixes,
+    });
 
     for (const url of urls) {
       const exists = await internalUrlExists(dirPath, url);