@dukebot/astro-html-validator 1.1.2 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dukebot/astro-html-validator",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Validate Astro-generated HTML output for SEO metadata, JSON-LD, and internal links.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -19,6 +19,8 @@
   ],
   "scripts": {
     "check": "node ./bin/cli.mjs --help",
+    "test": "node --test",
+    "test:links": "node --test tests/links-utils.test.mjs",
     "validate:dist": "node ./bin/cli.mjs"
   },
   "keywords": [
@@ -35,5 +37,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "parse5": "^8.0.0"
   }
 }

package/src/utils/links.mjs

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { parse } from 'parse5';
 import { pathExists } from './common.mjs';
 
 /**
@@ -30,15 +31,34 @@ function toLocalPathFromAbsolute(rawUrl, absolutePrefixes) {
 }
 
 /**
- * Removes non-rendered sections to avoid false positives when extracting links.
+ * Collects href/src attribute values from parsed HTML element nodes.
  */
-function sanitizeHtmlForLinkExtraction(html = '') {
-  if (!html) return '';
+function collectHtmlLinkAttributes(html = '') {
+  if (!html) return [];
+
+  const urls = [];
+  const document = parse(html, { sourceCodeLocationInfo: false });
+  const queue = [document];
+
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node) continue;
+
+    if (Array.isArray(node.attrs)) {
+      for (const attr of node.attrs) {
+        if (!attr?.name || !attr?.value) continue;
+        if (attr.name !== 'href' && attr.name !== 'src') continue;
+        urls.push(attr.value);
+      }
+    }
+
+    if (node.content) queue.push(node.content);
+    if (Array.isArray(node.childNodes) && node.childNodes.length > 0) {
+      queue.push(...node.childNodes);
+    }
+  }
 
-  return html
-    .replace(/<!--[\s\S]*?-->/g, '')
-    .replace(/<script\b[\s\S]*?<\/script>/gi, '')
-    .replace(/<style\b[\s\S]*?<\/style>/gi, '');
+  return urls;
 }
 
 /**
@@ -46,47 +66,35 @@ function sanitizeHtmlForLinkExtraction(html = '') {
  */
 export function extractInternalUrls(html, { absoluteUrlPrefixes = [] } = {}) {
   const urls = new Set();
-  const tagRegex = /<[^>]+>/g;
-  const attrRegex = /\b(?:href|src)\s*=\s*["']([^"']+)["']/gi;
   const absolutePrefixes = normalizeAbsolutePrefixes(absoluteUrlPrefixes);
-  const safeHtml = sanitizeHtmlForLinkExtraction(html);
-
-  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;
+  for (const value of collectHtmlLinkAttributes(html)) {
+    const raw = value?.trim();
+    if (!raw) continue;
+
+    if (
+      raw.startsWith('//') ||
+      raw.startsWith('#') ||
+      raw.startsWith('mailto:') ||
+      raw.startsWith('tel:') ||
+      raw.startsWith('javascript:') ||
+      raw.startsWith('data:')
+    ) {
+      continue;
+    }
 
-      if (clean.startsWith('/')) {
-        urls.add(clean);
-        continue;
-      }
+    const clean = raw.split(/[?#]/)[0];
+    if (!clean) continue;
 
-      if (clean.startsWith('http://') || clean.startsWith('https://')) {
-        const localPath = toLocalPathFromAbsolute(clean, absolutePrefixes);
-        if (localPath) urls.add(localPath);
-      }
+    if (clean.startsWith('/')) {
+      urls.add(clean);
+      continue;
     }
 
-    attrRegex.lastIndex = 0;
+    if (clean.startsWith('http://') || clean.startsWith('https://')) {
+      const localPath = toLocalPathFromAbsolute(clean, absolutePrefixes);
+      if (localPath) urls.add(localPath);
+    }
   }
 
   return [...urls];

package/src/utils/meta.mjs

@@ -1,122 +1,181 @@
-import { getAttr } from './common.mjs';
-
-// Core metadata tags expected on every page.
-export const REQUIRED_META_CHECKS = [
-  { label: 'meta title', check: getTitleContent },
-  { label: 'meta description', check: (html) => hasMeta(html, 'description') },
-  { label: 'canonical', check: hasCanonical },
-  { label: 'meta robots', check: (html) => hasMeta(html, 'robots') },
-  { label: 'og:title', check: (html) => hasMeta(html, 'og:title', true) },
-  { label: 'og:description', check: (html) => hasMeta(html, 'og:description', true) },
-  { label: 'og:url', check: (html) => hasMeta(html, 'og:url', true) },
-  { label: 'og:type', check: (html) => hasMeta(html, 'og:type', true) },
-];
-
-/**
- * Returns whether a meta tag exists with the expected key and non-empty content.
- */
-export function hasMeta(html, name, isProperty = false) {
-  const tags = html.match(/<meta\b[^>]*>/gi) || [];
-  return tags.some((tag) => {
-    const key = isProperty ? getAttr(tag, 'property') : getAttr(tag, 'name');
-    if (!key || key !== name) return false;
-    const content = getAttr(tag, 'content');
-    return !!content;
-  });
-}
-
-/**
- * Returns the `content` value for a meta tag by name/property.
- */
-export function getMetaContent(html, name, isProperty = false) {
-  const tags = html.match(/<meta\b[^>]*>/gi) || [];
-  for (const tag of tags) {
-    const key = isProperty ? getAttr(tag, 'property') : getAttr(tag, 'name');
-    if (!key || key !== name) continue;
-    const content = getAttr(tag, 'content');
-    if (content) return content;
-  }
-  return '';
-}
-
-/**
- * Checks that a canonical link tag exists with a non-empty href.
- */
-export function hasCanonical(html) {
-  const links = html.match(/<link\b[^>]*>/gi) || [];
-  return links.some((tag) => {
-    const rel = getAttr(tag, 'rel');
-    if (!rel || rel.toLowerCase() !== 'canonical') return false;
-    const href = getAttr(tag, 'href');
-    return !!href;
-  });
-}
-
-/**
- * Extracts the document title text.
- */
-export function getTitleContent(html) {
-  const match = html.match(/<title>([^<]+)<\/title>/i);
-  return match?.[1]?.trim() ?? '';
-}
-
-/**
- * Validates optional length ranges for title/description fields.
- */
-export function validateLengthRange({ value, min = 1, max = Infinity, fieldLabel }) {
-  if (!value) return;
-  if (value.length >= min && value.length <= max) return;
-  return `Recommended ${fieldLabel} length is ${min}-${max}. Current: ${value.length}.`;
-}
-
-/**
- * Evaluates all mandatory metadata checks for a page.
- */
-export function validateRequiredMeta(html) {
-  const warnings = [];
-
-  for (const item of REQUIRED_META_CHECKS) {
-    if (!item.check(html)) {
-      warnings.push(`Missing ${item.label}.`);
-    }
-  }
-
-  return warnings;
-}
-
-/**
- * Runs required and optional SEO metadata checks for one HTML string.
- */
-export function validateHtmlMeta(
-  html,
-  {
-    metaTitleMinLength,
-    metaTitleMaxLength,
-    metaDescriptionMinLength,
-    metaDescriptionMaxLength,
-  } = {}
-) {
-  const warnings = [];
-
-  warnings.push(...validateRequiredMeta(html));
-
-  warnings.push(
-    validateLengthRange({
-      value: getTitleContent(html),
-      min: metaTitleMinLength,
-      max: metaTitleMaxLength,
-      fieldLabel: 'meta title',
-    })
-  );
-
-  warnings.push(
-    validateLengthRange({
-      value: getMetaContent(html, 'description'),
-      min: metaDescriptionMinLength,
-      max: metaDescriptionMaxLength,
-      fieldLabel: 'meta description',
-    })
-  );
-
-  return warnings.filter(Boolean);
-}
+import { parse } from 'parse5';
+
+function parseHtmlDocument(html = '') {
+  if (!html) return null;
+  return parse(html, { sourceCodeLocationInfo: false });
+}
+
+function getAttrValue(node, attrName) {
+  if (!Array.isArray(node?.attrs)) return '';
+  const attr = node.attrs.find((item) => item?.name?.toLowerCase() === attrName.toLowerCase());
+  return attr?.value?.trim() ?? '';
+}
+
+function findFirstNode(root, predicate) {
+  if (!root) return null;
+
+  const queue = [root];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node) continue;
+    if (predicate(node)) return node;
+
+    if (node.content) queue.push(node.content);
+    if (Array.isArray(node.childNodes) && node.childNodes.length > 0) {
+      queue.push(...node.childNodes);
+    }
+  }
+
+  return null;
+}
+
+function getNodeText(node) {
+  if (!node) return '';
+
+  let text = '';
+  const queue = [node];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) continue;
+
+    if (current.nodeName === '#text' && typeof current.value === 'string') {
+      text += current.value;
+    }
+
+    if (current.content) queue.push(current.content);
+    if (Array.isArray(current.childNodes) && current.childNodes.length > 0) {
+      queue.push(...current.childNodes);
+    }
+  }
+
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function getMetaNode(document, name, isProperty = false) {
+  const attrName = isProperty ? 'property' : 'name';
+  const normalizedExpected = String(name).trim().toLowerCase();
+
+  return findFirstNode(document, (node) => {
+    if (node?.tagName !== 'meta') return false;
+    const key = getAttrValue(node, attrName).toLowerCase();
+    return key === normalizedExpected;
+  });
+}
+
+function getStringLength(value) {
+  return Array.from(value.normalize('NFC')).length;
+}
+
+// Core metadata tags expected on every page.
+export const REQUIRED_META_CHECKS = [
+  { label: 'meta title', check: getTitleContent },
+  { label: 'meta description', check: (html) => hasMeta(html, 'description') },
+  { label: 'canonical', check: hasCanonical },
+  { label: 'meta robots', check: (html) => hasMeta(html, 'robots') },
+  { label: 'og:title', check: (html) => hasMeta(html, 'og:title', true) },
+  { label: 'og:description', check: (html) => hasMeta(html, 'og:description', true) },
+  { label: 'og:url', check: (html) => hasMeta(html, 'og:url', true) },
+  { label: 'og:type', check: (html) => hasMeta(html, 'og:type', true) },
+];
+
+/**
+ * Returns whether a meta tag exists with the expected key and non-empty content.
+ */
+export function hasMeta(html, name, isProperty = false) {
+  return !!getMetaContent(html, name, isProperty);
+}
+
+/**
+ * Returns the `content` value for a meta tag by name/property.
+ */
+export function getMetaContent(html, name, isProperty = false) {
+  const document = parseHtmlDocument(html);
+  const node = getMetaNode(document, name, isProperty);
+  return getAttrValue(node, 'content');
+}
+
+/**
+ * Checks that a canonical link tag exists with a non-empty href.
+ */
+export function hasCanonical(html) {
+  const document = parseHtmlDocument(html);
+
+  return !!findFirstNode(document, (node) => {
+    if (node?.tagName !== 'link') return false;
+    const rel = getAttrValue(node, 'rel').toLowerCase();
+    if (rel !== 'canonical') return false;
+    return !!getAttrValue(node, 'href');
+  });
+}
+
+/**
+ * Extracts the document title text.
+ */
+export function getTitleContent(html) {
+  const document = parseHtmlDocument(html);
+  const titleNode = findFirstNode(document, (node) => node?.tagName === 'title');
+  return getNodeText(titleNode);
+}
+
+/**
+ * Validates optional length ranges for title/description fields.
+ */
+export function validateLengthRange({ value, min = 1, max = Infinity, fieldLabel }) {
+  if (!value) return;
+
+  const length = getStringLength(value);
+  if (length >= min && length <= max) return;
+  return `Recommended ${fieldLabel} length is ${min}-${max}. Current: ${length}.`;
+}
+
+/**
+ * Evaluates all mandatory metadata checks for a page.
+ */
+export function validateRequiredMeta(html) {
+  const warnings = [];
+
+  for (const item of REQUIRED_META_CHECKS) {
+    if (!item.check(html)) {
+      warnings.push(`Missing ${item.label}.`);
+    }
+  }
+
+  return warnings;
+}
+
+/**
+ * Runs required and optional SEO metadata checks for one HTML string.
+ */
+export function validateHtmlMeta(
+  html,
+  {
+    metaTitleMinLength,
+    metaTitleMaxLength,
+    metaDescriptionMinLength,
+    metaDescriptionMaxLength,
+  } = {}
+) {
+  const warnings = [];
+
+  warnings.push(...validateRequiredMeta(html));
+
+  warnings.push(
+    validateLengthRange({
+      value: getTitleContent(html),
+      min: metaTitleMinLength,
+      max: metaTitleMaxLength,
+      fieldLabel: 'meta title',
+    })
+  );
+
+  warnings.push(
+    validateLengthRange({
+      value: getMetaContent(html, 'description'),
+      min: metaDescriptionMinLength,
+      max: metaDescriptionMaxLength,
+      fieldLabel: 'meta description',
+    })
+  );
+
+  return warnings.filter(Boolean);
+}