npm - @dukebot/astro-html-validator - Versions diffs - 1.0.0 → 1.1.1 - Mend

@dukebot/astro-html-validator 1.0.0 → 1.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +47 -2
package/bin/cli.mjs +20 -1
package/package.json +1 -1
package/src/index.mjs +90 -3
package/src/utils/jsonld.mjs +102 -0
package/src/utils/links.mjs +89 -0
package/src/utils/meta.mjs +122 -0
package/src/validator.mjs +27 -81
package/src/validators/jsonld.mjs +77 -60
package/src/validators/links.mjs +32 -72
package/src/validators/meta.mjs +27 -120
/package/src/{utils.mjs → utils/common.mjs} +0 -0

package/README.md CHANGED Viewed

@@ -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
 ```
@@ -61,8 +63,15 @@ import { Validator } from '@dukebot/astro-html-validator';
 const validator = new Validator({
   dirPath: path.resolve(process.cwd(), 'dist'),
   config: {
-    jsonld: {},
-    links: {},
+    jsonld: {
+      requireHtmlLang: true,
+      requireInLanguage: true,
+      disallowEmptyInLanguage: true,
+      requireLangMatch: true,
+    },
+    links: {
+      absoluteUrlPrefixes: ['https://example.com', 'https://www.example.com'],
+    },
     meta: {
       metaTitleMinLength: 30,
       metaTitleMaxLength: 60,
@@ -77,6 +86,34 @@ 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.
+- `src/validator.mjs` now contains the **base validator class** used via inheritance by concrete validators.
+- Each concrete validator (`jsonld`, `links`, `meta`) encapsulates its own config and page-level validation.
+### JSON-LD language consistency options
+`config.jsonld` now supports optional checks to validate language consistency between `<html lang="...">` and JSON-LD `inLanguage` values:
+- `requireHtmlLang` (default: `false`)
+- `requireInLanguage` (default: `false`)
+- `disallowEmptyInLanguage` (default: `false`)
+- `requireLangMatch` (default: `false`)
+When enabled, warnings are reported through the normal validator output (`[WARN] /route -> ...`) so existing integrations remain backward-compatible.
 ---
 ## Suggested scripts for your Astro project
@@ -98,6 +135,7 @@ console.log(results);
 Quick steps:
 1. Update `name`, `author`, and `version` in `package.json`.
+   - For this release, use a **major bump** (breaking changes accepted).
 2. Sign in:
    ```bash
@@ -110,6 +148,13 @@ Quick steps:
    npm publish --access public
    ```
+### Breaking change note
+`@dukebot/astro-html-validator/validator` now points to the **base validator class** (`src/validator.mjs`) instead of the previous coordinator implementation.

package/bin/cli.mjs CHANGED Viewed

@@ -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 CHANGED Viewed

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

package/src/index.mjs CHANGED Viewed

@@ -1,4 +1,91 @@
-import { Validator } from './validator.mjs';
+import { JsonldValidator } from './validators/jsonld.mjs';
+import { LinksValidator } from './validators/links.mjs';
+import { MetaValidator } from './validators/meta.mjs';
-export { Validator };
-export default Validator;
+/**
+ * Coordinates all available validators and prints optional summaries.
+ */
+export class HtmlValidator {
+  /**
+   * Builds a validator coordinator with directory, per-validator config, and output mode.
+   */
+  constructor({ dirPath, config = {}, print = true } = {}) {
+    this.dirPath = dirPath;
+    this.validators = {
+      jsonld: new JsonldValidator(config.jsonld),
+      links: new LinksValidator(config.links),
+      meta: new MetaValidator(config.meta),
+    };
+    this.print = print;
+  }
+  /**
+   * Resolves a selector string into a unique list of validator names.
+   */
+  _selectValidators(selector = 'all') {
+    const clean = selector.trim().toLowerCase();
+    if (clean === 'all') return Object.keys(this.validators);
+    const selected = clean
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean);
+    const invalid = selected.filter((name) => !this.validators[name]);
+    if (invalid.length > 0) {
+      throw new Error(
+        `Unknown validators: ${invalid.join(', ')}. ` +
+          `Valid options: all, ${Object.keys(this.validators).join(', ')}`
+      );
+    }
+    return [...new Set(selected)];
+  }
+  /**
+   * Prints a consistent summary for one validator result.
+   */
+  _printResultSummary(result) {
+    console.log(`\n=== ${result.label} ===`);
+    console.log(`Checked ${result.checkedPages} HTML pages.`);
+    if (result.warnings.length === 0) {
+      console.log('✅ No warnings.');
+      return;
+    }
+    console.log(`⚠️  Warnings found: ${result.warnings.length}`);
+    for (const warning of result.warnings) console.log(warning);
+  }
+  /**
+   * Runs one validator by name.
+   */
+  async runValidator(name) {
+    const validator = this.validators[name];
+    const result = await validator.validate(this.dirPath);
+    if (this.print) this._printResultSummary(result);
+    return result;
+  }
+  /**
+   * Runs selected validators sequentially.
+   */
+  async run({ selector = 'all' } = {}) {
+    const results = [];
+    const selectedNames = this._selectValidators(selector);
+    for (const name of selectedNames) {
+      const result = await this.runValidator(name);
+      results.push(result);
+    }
+    return results;
+  }
+}
+export { HtmlValidator as Validator };
+export default HtmlValidator;

package/src/utils/jsonld.mjs ADDED Viewed

@@ -0,0 +1,102 @@
+/**
+ * Extracts the language code declared on the <html> element.
+ */
+export function extractHtmlLang(html) {
+  const match = html.match(/<html[^>]*\blang=["']([^"']+)["']/i);
+  return match?.[1]?.trim() ?? '';
+}
+/**
+ * Recursively collects all inLanguage values from a JSON-LD node tree.
+ */
+export function collectInLanguageValues(node, out = []) {
+  if (Array.isArray(node)) {
+    for (const item of node) collectInLanguageValues(item, out);
+    return out;
+  }
+  if (!node || typeof node !== 'object') return out;
+  if (Object.hasOwn(node, 'inLanguage')) {
+    out.push(node.inLanguage);
+  }
+  for (const value of Object.values(node)) {
+    collectInLanguageValues(value, out);
+  }
+  return out;
+}
+/**
+ * Checks whether any inLanguage value is empty, null, or undefined.
+ */
+export function hasEmptyInLanguage(values) {
+  return values.some((value) => {
+    if (value == null) return true;
+    if (typeof value === 'string') return value.trim().length === 0;
+    if (Array.isArray(value)) {
+      return value.some((item) => {
+        if (item == null) return true;
+        if (typeof item !== 'string') return false;
+        return item.trim().length === 0;
+      });
+    }
+    return false;
+  });
+}
+/**
+ * Returns true when at least one inLanguage value matches the HTML lang.
+ */
+export function hasHtmlLang(values, htmlLang) {
+  const normalizedHtmlLang = htmlLang.trim().toLowerCase();
+  return values.some((value) => {
+    if (typeof value === 'string') {
+      return value.trim().toLowerCase() === normalizedHtmlLang;
+    }
+    if (Array.isArray(value)) {
+      return value.some(
+        (item) => typeof item === 'string' && item.trim().toLowerCase() === normalizedHtmlLang
+      );
+    }
+    return false;
+  });
+}
+/**
+ * Extracts and parses JSON-LD script blocks from a page.
+ */
+export function getJsonLdBlocks(html) {
+  const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  const blocks = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      blocks.push(JSON.parse(raw));
+    } catch {
+      blocks.push({ __parseError: true, __raw: raw });
+    }
+  }
+  return blocks;
+}
+/**
+ * Flattens top-level JSON-LD nodes and @graph nodes into one list.
+ */
+export function getGraphNodes(blocks) {
+  const nodes = [];
+  for (const block of blocks) {
+    if (block.__parseError) continue;
+    if (Array.isArray(block['@graph'])) nodes.push(...block['@graph']);
+    else nodes.push(block);
+  }
+  return nodes;
+}

package/src/utils/links.mjs ADDED Viewed

@@ -0,0 +1,89 @@
+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;
+}
+/**
+ * Extracts local (root-relative) URLs from href/src attributes.
+ */
+export function extractInternalUrls(html, { absoluteUrlPrefixes = [] } = {}) {
+  const urls = new Set();
+  const regex = /(?:href|src)=["']([^"']+)["']/gi;
+  const absolutePrefixes = normalizeAbsolutePrefixes(absoluteUrlPrefixes);
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const raw = match[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('/')) {
+      if (clean) urls.add(clean);
+      continue;
+    }
+    if (clean.startsWith('http://') || clean.startsWith('https://')) {
+      const localPath = toLocalPathFromAbsolute(clean, absolutePrefixes);
+      if (localPath) urls.add(localPath);
+    }
+  }
+  return [...urls];
+}
+/**
+ * Checks whether an internal URL resolves to an HTML file in dist.
+ */
+export async function internalUrlExists(dirPath, urlPath) {
+  if (urlPath === '/') return pathExists(path.join(dirPath, 'index.html'));
+  const asFile = path.join(dirPath, urlPath.replace(/^\//, ''));
+  if (await pathExists(asFile)) return true;
+  const asIndex = path.join(dirPath, urlPath.replace(/^\//, ''), 'index.html');
+  if (await pathExists(asIndex)) return true;
+  const asHtml = path.join(dirPath, `${urlPath.replace(/^\//, '')}.html`);
+  if (await pathExists(asHtml)) return true;
+  return false;
+}

package/src/utils/meta.mjs ADDED Viewed

@@ -0,0 +1,122 @@
+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);
+}

package/src/validator.mjs CHANGED Viewed

@@ -1,98 +1,44 @@
-import { validateJsonld } from './validators/jsonld.mjs';
-import { validateLinks } from './validators/links.mjs';
-import { validateMeta } from './validators/meta.mjs';
+import { runHtmlValidation } from './utils/common.mjs';
 /**
- * Coordinates all available validators and prints optional summaries.
+ * Base validator with shared execution flow for HTML page-by-page checks.
  */
 export class Validator {
-  constructor({ dirPath, config = {}, print = true } = {}) {
-    this.dirPath = dirPath;
-    this.validators = {
-      jsonld: {
-        label: 'JSON-LD',
-        run: validateJsonld,
-        config: config.jsonld,
-      },
-      links: {
-        label: 'Internal links',
-        run: validateLinks,
-        config: config.links,
-      },
-      meta: {
-        label: 'SEO metadata',
-        run: validateMeta,
-        config: config.meta,
-      },
-    };
-    this.print = print;
-  }
-  /**
-   * Resolves a selector string into a unique list of validator names.
-   */
-  selectValidators(selector = 'all') {
-    const clean = selector.trim().toLowerCase();
-    if (clean === 'all') return Object.keys(this.validators);
-    const selected = clean
-      .split(',')
-      .map((item) => item.trim())
-      .filter(Boolean);
-    const invalid = selected.filter((name) => !this.validators[name]);
-    if (invalid.length > 0) {
-      throw new Error(
-        `Unknown validators: ${invalid.join(', ')}. ` +
-          `Valid options: all, ${Object.keys(this.validators).join(', ')}`
-      );
-    }
-    return [...new Set(selected)];
-  }
   /**
-   * Prints a consistent summary for one validator result.
+   * Initializes shared validator metadata and config.
    */
-  printResultSummary(result) {
-    console.log(`\n=== ${result.label} ===`);
-    console.log(`Checked ${result.checkedPages} HTML pages.`);
-    if (result.warnings.length === 0) {
-      console.log('✅ No warnings.');
-      return;
-    }
+  constructor({ name, label, config = {} } = {}) {
+    if (!name) throw new Error('Validator name is required.');
+    if (!label) throw new Error('Validator label is required.');
-    console.log(`⚠️  Warnings found: ${result.warnings.length}`);
-    for (const warning of result.warnings) console.log(warning);
+    this.name = name;
+    this.label = label;
+    this.config = config;
   }
   /**
-   * Runs one validator by name.
+   * Runs full validation over all HTML pages.
    */
-  async runValidator(name) {
-    const validator = this.validators[name];
-    const result = await validator.run(this.dirPath, validator.config);
-    result.label = validator.label;
-    if (this.print) this.printResultSummary(result);
-    return result;
+  async validate(dirPath) {
+    const { checkedPages, warnings } = await runHtmlValidation({
+      dirPath,
+      validatePage: (pageContext) => this.validatePage({ ...pageContext, dirPath }),
+    });
+    return {
+      name: this.name,
+      label: this.label,
+      checkedPages,
+      warnings,
+    };
   }
   /**
-   * Runs selected validators sequentially.
+   * Validates one page. Child classes must override this.
    */
-  async run({ selector = 'all' } = {}) {
-    const results = [];
-    const selectedNames = this.selectValidators(selector);
-    for (const name of selectedNames) {
-      const result = await this.runValidator(name);
-      results.push(result);
-    }
-    return results;
+  async validatePage() {
+    throw new Error('validatePage() must be implemented by child validators.');
   }
 }
+export default Validator;

package/src/validators/jsonld.mjs CHANGED Viewed

@@ -1,74 +1,91 @@
-import { runHtmlValidation } from '../utils.mjs';
+import { Validator } from '../validator.mjs';
+import {
+  collectInLanguageValues,
+  extractHtmlLang,
+  getGraphNodes,
+  getJsonLdBlocks,
+  hasEmptyInLanguage,
+  hasHtmlLang,
+} from '../utils/jsonld.mjs';
-/**
- * Extracts and parses JSON-LD script blocks from a page.
- */
-function getJsonLdBlocks(html) {
-  const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-  const blocks = [];
-  let match;
+export class JsonldValidator extends Validator {
+  /**
+   * Stores JSON-LD language consistency options for this validator instance.
+   */
+  constructor({
+    requireHtmlLang = false,
+    requireInLanguage = false,
+    disallowEmptyInLanguage = false,
+    requireLangMatch = false,
+  } = {}) {
+    super({
+      name: 'jsonld',
+      label: 'JSON-LD',
+      config: {
+        requireHtmlLang,
+        requireInLanguage,
+        disallowEmptyInLanguage,
+        requireLangMatch,
+      },
+    });
+  }
+  /**
+   * Applies language-related JSON-LD checks for one parsed HTML page.
+   */
+  validateJsonLdLanguage({ html, nodes }) {
+    const warnings = [];
+    const htmlLang = extractHtmlLang(html);
+    const inLanguageValues = collectInLanguageValues(nodes);
-  while ((match = regex.exec(html)) !== null) {
-    const raw = match[1]?.trim();
-    if (!raw) continue;
-    try {
-      blocks.push(JSON.parse(raw));
-    } catch {
-      blocks.push({ __parseError: true, __raw: raw });
+    if (this.config.requireHtmlLang && !htmlLang) {
+      warnings.push('Missing <html lang="..."> value to validate JSON-LD language consistency.');
+      return warnings;
     }
-  }
-  return blocks;
-}
+    if (this.config.requireInLanguage && inLanguageValues.length === 0) {
+      warnings.push('No inLanguage property was found in JSON-LD.');
+      return warnings;
+    }
-/**
- * Flattens top-level JSON-LD nodes and @graph nodes into one list.
- */
-function getGraphNodes(blocks) {
-  const nodes = [];
-  for (const block of blocks) {
-    if (block.__parseError) continue;
-    if (Array.isArray(block['@graph'])) nodes.push(...block['@graph']);
-    else nodes.push(block);
-  }
-  return nodes;
-}
+    if (this.config.disallowEmptyInLanguage && hasEmptyInLanguage(inLanguageValues)) {
+      warnings.push('Found empty or null inLanguage value(s) in JSON-LD.');
+    }
+    if (this.config.requireLangMatch && htmlLang && !hasHtmlLang(inLanguageValues, htmlLang)) {
+      warnings.push(`No JSON-LD inLanguage matches <html lang="${htmlLang}">.`);
+    }
-/**
- * Validates JSON-LD presence/basic parseability for each HTML page.
- */
-export async function validateJsonld(dirPath) {
-  const { checkedPages, warnings } = await runHtmlValidation({
-    dirPath,
-    validatePage: ({ html }) => {
-      const pageWarnings = [];
-      const blocks = getJsonLdBlocks(html);
+    return warnings;
+  }
-      if (blocks.length === 0) {
-        pageWarnings.push('No JSON-LD block was found.');
-        return pageWarnings;
-      }
+  /**
+   * Validates JSON-LD structure and optional language consistency for one page.
+   */
+  validatePage({ html }) {
+    const pageWarnings = [];
+    const blocks = getJsonLdBlocks(html);
-      if (blocks.some((b) => b.__parseError)) {
-        pageWarnings.push('At least one JSON-LD block has invalid JSON.');
-        return pageWarnings;
-      }
+    if (blocks.length === 0) {
+      pageWarnings.push('No JSON-LD block was found.');
+      return pageWarnings;
+    }
-      const nodes = getGraphNodes(blocks);
+    if (blocks.some((b) => b.__parseError)) {
+      pageWarnings.push('At least one JSON-LD block has invalid JSON.');
+      return pageWarnings;
+    }
-      if (nodes.length === 0) {
-        pageWarnings.push('JSON-LD exists but has no nodes in @graph.');
-        return pageWarnings;
-      }
+    const nodes = getGraphNodes(blocks);
+    if (nodes.length === 0) {
+      pageWarnings.push('JSON-LD exists but has no nodes in @graph.');
       return pageWarnings;
-    },
-  });
+    }
-  return {
-    name: 'jsonld',
-    label: 'JSON-LD',
-    checkedPages,
-    warnings,
-  };
+    pageWarnings.push(...this.validateJsonLdLanguage({ html, nodes }));
+    return pageWarnings;
+  }
 }
+export default JsonldValidator

package/src/validators/links.mjs CHANGED Viewed

@@ -1,81 +1,41 @@
-import path from 'node:path';
-import { pathExists, runHtmlValidation } from '../utils.mjs';
+import { Validator } from '../validator.mjs';
+import { extractInternalUrls, internalUrlExists } from '../utils/links.mjs';
 /**
- * Extracts local (root-relative) URLs from href/src attributes.
+ * Reports broken internal links for each generated HTML page.
  */
-function extractInternalUrls(html) {
-  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;
+export class LinksValidator extends Validator {
+  /**
+   * Initializes link validator configuration (reserved for future rules).
+   */
+  constructor({
+    absoluteUrlPrefixes = [],
+  } = {}) {
+    super({
+      name: 'links',
+      label: 'Internal links',
+      config: {
+        absoluteUrlPrefixes,
+      },
+    });
+  }
-    if (
-      raw.startsWith('http://') ||
-      raw.startsWith('https://') ||
-      raw.startsWith('//') ||
-      raw.startsWith('#') ||
-      raw.startsWith('mailto:') ||
-      raw.startsWith('tel:') ||
-      raw.startsWith('javascript:') ||
-      raw.startsWith('data:')
-    ) {
-      continue;
+  /**
+   * Validates internal link targets for one HTML page.
+   */
+  async validatePage({ html, dirPath }) {
+    const pageWarnings = [];
+    const urls = extractInternalUrls(html, {
+      absoluteUrlPrefixes: this.config.absoluteUrlPrefixes,
+    });
+    for (const url of urls) {
+      const exists = await internalUrlExists(dirPath, url);
+      if (!exists) pageWarnings.push(`Internal link not found: ${url}`);
     }
-    if (raw.startsWith('/')) {
-      const clean = raw.split('#')[0].split('?')[0];
-      if (clean) urls.add(clean);
-    }
+    return pageWarnings;
   }
-  return [...urls];
-}
-/**
- * Checks whether an internal URL resolves to an HTML file in dist.
- */
-async function internalUrlExists(dirPath, urlPath) {
-  if (urlPath === '/') return pathExists(path.join(dirPath, 'index.html'));
-  const asFile = path.join(dirPath, urlPath.replace(/^\//, ''));
-  if (await pathExists(asFile)) return true;
-  const asIndex = path.join(dirPath, urlPath.replace(/^\//, ''), 'index.html');
-  if (await pathExists(asIndex)) return true;
-  const asHtml = path.join(dirPath, `${urlPath.replace(/^\//, '')}.html`);
-  if (await pathExists(asHtml)) return true;
-  return false;
 }
-/**
- * Reports broken internal links for each generated HTML page.
- */
-export async function validateLinks(dirPath) {
-  const { checkedPages, warnings } = await runHtmlValidation({
-    dirPath,
-    validatePage: async ({ html }) => {
-      const pageWarnings = [];
-      const urls = extractInternalUrls(html);
-      for (const url of urls) {
-        const exists = await internalUrlExists(dirPath, url);
-        if (!exists) pageWarnings.push(`Internal link not found: ${url}`);
-      }
-      return pageWarnings;
-    },
-  });
-  return {
-    name: 'links',
-    label: 'Internal links',
-    checkedPages,
-    warnings,
-  };
-}
+export default LinksValidator

package/src/validators/meta.mjs CHANGED Viewed

@@ -1,130 +1,37 @@
-import { getAttr, runHtmlValidation } from '../utils.mjs';
-// Core metadata tags expected on every page.
-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) },
-];
-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.
- */
-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.
- */
-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;
-  });
-}
-function getTitleContent(html) {
-  const match = html.match(/<title>([^<]+)<\/title>/i);
-  return match?.[1]?.trim() ?? '';
-}
-/**
- * Validates optional length ranges for title/description fields.
- */
-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}.`;
-}
-function validateRequiredMeta(html) {
-  const warnings = [];
-  for (const item of REQUIRED_META_CHECKS) {
-    if (!item.check(html)) {
-      warnings.push(`Missing ${item.label}.`);
-    }
-  }
-  return warnings;
-}
+import { Validator } from '../validator.mjs';
+import { validateHtmlMeta } from '../utils/meta.mjs';
 /**
- * Runs required and optional SEO metadata checks for one HTML string.
+ * Validates required SEO metadata and optional length recommendations.
  */
-function validateHtmlMeta(
-  html,
-  {
+export class MetaValidator extends Validator {
+  /**
+   * Stores metadata validation thresholds for this validator instance.
+   */
+  constructor({
     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',
-    })
-  );
+  } = {}) {
+    super({
+      name: 'meta',
+      label: 'SEO metadata',
+      config: {
+        metaTitleMinLength,
+        metaTitleMaxLength,
+        metaDescriptionMinLength,
+        metaDescriptionMaxLength,
+      },
+    });
+  }
-  return warnings.filter(Boolean);
+  /**
+   * Validates metadata rules for one HTML page.
+   */
+  validatePage({ html }) {
+    return validateHtmlMeta(html, this.config);
+  }
 }
-/**
- * Validates SEO metadata for every HTML page in dist.
- */
-export async function validateMeta(dirPath, options) {
-  const { checkedPages, warnings } = await runHtmlValidation({
-    dirPath,
-    validatePage: ({ html }) => validateHtmlMeta(html, options),
-  });
-  return {
-    name: 'meta',
-    label: 'SEO metadata',
-    checkedPages,
-    warnings,
-  };
-}
+export default MetaValidator

/package/src/{utils.mjs → utils/common.mjs} RENAMED Viewed

File without changes