npm - @holmdigital/engine - Versions diffs - 1.2.0 - Mend

@holmdigital/engine 1.2.0

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 (15) hide show

package/dist/cli/index.mjs ADDED Viewed

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import {
+  PseudoAutomationEngine,
+  RegulatoryScanner
+} from "../chunk-MFACMI2F.mjs";
+import {
+  getCurrentLang,
+  setLanguage,
+  t
+} from "../chunk-OXZPYWBW.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+// src/reporting/html-template.ts
+function generateReportHTML(result) {
+  const criticalCount = result.stats.critical;
+  const highCount = result.stats.high;
+  const scoreColor = result.score > 90 ? "#16a34a" : result.score > 70 ? "#eab308" : "#dc2626";
+  const formatDate = (dateString) => {
+    return new Date(dateString).toLocaleDateString(getCurrentLang() === "sv" ? "sv-SE" : "en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  };
+  return `
+    <!DOCTYPE html>
+    <html lang="${getCurrentLang()}">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>${t("report.title", { url: result.url })}</title>
+        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+        <style>
+            @page {
+                margin: 0;
+            }
+            body {
+                font-family: 'Inter', sans-serif;
+                background-color: #ffffff;
+                color: #0f172a;
+                margin: 0;
+                padding: 40px;
+                -webkit-print-color-adjust: exact;
+            }
+            .header {
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                border-bottom: 2px solid #f1f5f9;
+                padding-bottom: 2rem;
+                margin-bottom: 3rem;
+            }
+            .brand {
+                font-size: 1.5rem;
+                font-weight: 700;
+                color: #0f172a;
+            }
+            .brand span {
+                color: #0ea5e9;
+            }
+            .meta {
+                text-align: right;
+                color: #64748b;
+                font-size: 0.875rem;
+            }
+            .summary-grid {
+                display: grid;
+                grid-template-columns: repeat(4, 1fr);
+                gap: 1.5rem;
+                margin-bottom: 3rem;
+            }
+            .card {
+                background: #f8fafc;
+                border: 1px solid #e2e8f0;
+                border-radius: 12px;
+                padding: 1.5rem;
+            }
+            .score-card {
+                background: #f0f9ff;
+                border-color: #bae6fd;
+            }
+            .metric-label {
+                font-size: 0.875rem;
+                color: #64748b;
+                margin-bottom: 0.5rem;
+                font-weight: 500;
+            }
+            .metric-value {
+                font-size: 2rem;
+                font-weight: 700;
+                color: #0f172a;
+            }
+            .section-title {
+                font-size: 1.25rem;
+                font-weight: 700;
+                margin-bottom: 1.5rem;
+                color: #0f172a;
+            }
+            .violation-card {
+                background: white;
+                border: 1px solid #e2e8f0;
+                border-radius: 8px;
+                padding: 1.5rem;
+                margin-bottom: 1rem;
+                page-break-inside: avoid;
+            }
+            .violation-header {
+                display: flex;
+                justify-content: space-between;
+                align-items: flex-start;
+                margin-bottom: 1rem;
+            }
+            .violation-title {
+                font-weight: 600;
+                font-size: 1.125rem;
+                color: #0f172a;
+            }
+            .badge {
+                display: inline-block;
+                padding: 0.25rem 0.75rem;
+                border-radius: 9999px;
+                font-size: 0.75rem;
+                font-weight: 600;
+                text-transform: uppercase;
+            }
+            .badge-critical { background: #fef2f2; color: #dc2626; border: 1px solid #fecaca; }
+            .badge-high { background: #fffbeb; color: #d97706; border: 1px solid #fde68a; }
+            .badge-medium { background: #fefce8; color: #ca8a04; border: 1px solid #fef08a; }
+            .badge-low { background: #f8fafc; color: #475569; border: 1px solid #e2e8f0; }
+            .violation-meta {
+                font-size: 0.875rem;
+                color: #64748b;
+                margin-bottom: 1rem;
+                padding-bottom: 1rem;
+                border-bottom: 1px solid #f1f5f9;
+            }
+            .remediation-box {
+                background: #f0fdf4;
+                border: 1px solid #bbf7d0;
+                border-radius: 6px;
+                padding: 1rem;
+                margin-top: 1rem;
+            }
+            .remediation-title {
+                color: #166534;
+                font-weight: 600;
+                font-size: 0.875rem;
+                margin-bottom: 0.5rem;
+            }
+            .remediation-text {
+                color: #15803d;
+                font-size: 0.875rem;
+            }
+            footer {
+                margin-top: 4rem;
+                text-align: center;
+                color: #94a3b8;
+                font-size: 0.75rem;
+                border-top: 1px solid #f1f5f9;
+                padding-top: 2rem;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="header">
+            <div class="brand">Holm<span>Digital</span></div>
+            <div class="meta">
+                <div>${t("report.scan_target", { url: result.url })}</div>
+                <div>${t("report.generated", { date: formatDate(result.timestamp) })}</div>
+            </div>
+        </div>
+        <div class="summary-grid">
+            <div class="card score-card">
+                <div class="metric-label" style="color: #0369a1;">${t("report.overall_score")}</div>
+                <div class="metric-value" style="color: ${scoreColor};">${Math.round(result.score)}</div>
+            </div>
+            <div class="card">
+                <div class="metric-label">${t("report.critical_issues")}</div>
+                <div class="metric-value" style="color: #dc2626;">${criticalCount}</div>
+            </div>
+            <div class="card">
+                <div class="metric-label">${t("report.high_issues")}</div>
+                <div class="metric-value" style="color: #d97706;">${highCount}</div>
+            </div>
+            <div class="card">
+                <div class="metric-label">${t("report.total_issues")}</div>
+                <div class="metric-value">${result.stats.total}</div>
+            </div>
+        </div>
+        <div class="section-title">${t("report.detailed_violations")}</div>
+        ${result.reports.map((report) => {
+    const riskClass = `badge-${report.holmdigitalInsight.diggRisk}`;
+    return `
+            <div class="violation-card">
+                <div class="violation-header">
+                    <div class="violation-title">${report.ruleId}</div>
+                    <span class="badge ${riskClass}">${report.holmdigitalInsight.diggRisk}</span>
+                </div>
+                <div class="violation-meta">
+                    WCAG ${report.wcagCriteria} \u2022 EN 301 549 ${report.en301549Criteria}
+                    ${report.dosLagenReference ? `\u2022 ${report.dosLagenReference}` : ""}
+                </div>
+                <div style="font-size: 0.95rem; color: #334155; line-height: 1.5;">
+                    ${report.holmdigitalInsight.swedishInterpretation}
+                    ${report.holmdigitalInsight.priorityRationale ? `<br/><br/><strong>Priority Rationale:</strong> ${report.holmdigitalInsight.priorityRationale}` : ""}
+                </div>
+                ${report.remediation.component ? `
+                <div class="remediation-box">
+                    <div class="remediation-title">${t("report.prescriptive_fix")}</div>
+                    <div class="remediation-text">${t("report.use")} <strong>${report.remediation.component}</strong>: ${report.remediation.description}</div>
+                </div>
+                ` : ""}
+            </div>
+            `;
+  }).join("")}
+        <footer>
+            ${t("report.footer")}
+        </footer>
+    </body>
+    </html>
+    `;
+}
+// src/reporting/pdf-generator.ts
+import puppeteer from "puppeteer";
+async function generatePDF(htmlContent, outputPath) {
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setContent(htmlContent, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.pdf({
+      path: outputPath,
+      format: "A4",
+      printBackground: true,
+      margin: {
+        top: "0px",
+        right: "0px",
+        bottom: "0px",
+        left: "0px"
+      }
+    });
+  } finally {
+    await browser.close();
+  }
+}
+// src/cli/cloud-client.ts
+var ENGINE_VERSION = "1.1.0";
+function transformToCloudPayload(result) {
+  const violations = result.reports.map((report) => {
+    const firstNode = report.failingNodes?.[0];
+    return {
+      rule_id: report.ruleId,
+      impact: report.holmdigitalInsight?.diggRisk || "medium",
+      wcag_criteria: report.wcagCriteria ? [report.wcagCriteria] : [],
+      element_selector: firstNode?.target || "",
+      element_html: firstNode?.html || "",
+      failure_summary: report.holmdigitalInsight?.reasoning || report.remediation?.description || "",
+      fix_suggestion: report.remediation?.description || ""
+    };
+  });
+  return {
+    url: result.url,
+    compliance_score: result.score,
+    compliance_status: result.complianceStatus,
+    total_violations: result.stats.total,
+    critical_count: result.stats.critical,
+    serious_count: result.stats.high,
+    moderate_count: result.stats.medium,
+    minor_count: result.stats.low,
+    engine_version: ENGINE_VERSION,
+    violations
+  };
+}
+async function sendToCloud(config, result) {
+  const payload = transformToCloudPayload(result);
+  const endpoint = `${config.cloudUrl.replace(/\/$/, "")}/api/v1/ingest`;
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 401) {
+        return {
+          success: false,
+          error: "Authentication failed. Please check your API key."
+        };
+      }
+      if (response.status === 403) {
+        return {
+          success: false,
+          error: "Access denied. Your API key may not have permission for this action."
+        };
+      }
+      return {
+        success: false,
+        error: `Server error (${response.status}): ${errorText}`
+      };
+    }
+    const data = await response.json().catch(() => ({}));
+    return {
+      success: true,
+      message: data.message || "Results uploaded successfully"
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("ENOTFOUND") || errorMessage.includes("ECONNREFUSED")) {
+      return {
+        success: false,
+        error: `Could not connect to cloud server at ${config.cloudUrl}`
+      };
+    }
+    return {
+      success: false,
+      error: `Network error: ${errorMessage}`
+    };
+  }
+}
+// src/cli/index.ts
+function isValidUrl(urlString) {
+  try {
+    const url = new URL(urlString);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var program = new Command();
+program.name("hd-a11y-scan").description("HolmDigital Regulatory Scanner").version("0.1.0");
+program.argument("<url>", "URL to scan").option("--lang <code", "Language code (en, sv)", "en").option("--ci", "Run in CI/CD mode (exit code 1 on critical failures)").option("--generate-tests", "Generate Pseudo-Automation tests").option("--json", "Output as JSON").option("--pdf <path>", "Generate PDF report to path").option("--viewport <size>", 'Set viewport (e.g. "mobile", "desktop", "1024x768")').option("--api-key <key>", "API key for HolmDigital Cloud authentication").option("--cloud-url <url>", "Cloud API URL", "https://cloud.holmdigital.se").action(async (url, options) => {
+  setLanguage(options.lang);
+  if (!isValidUrl(url)) {
+    console.error(chalk.red(`Error: Invalid URL format '${url}'`));
+    console.error(chalk.gray("URL must start with http:// or https://"));
+    process.exit(1);
+  }
+  if (!options.json) {
+    console.log(chalk.blue.bold(t("cli.title")));
+    console.log(chalk.gray(t("cli.scanning", { url })));
+  }
+  const spinner = !options.json ? ora(t("cli.initializing")).start() : null;
+  let scanner;
+  try {
+    let viewport = { width: 1280, height: 720 };
+    if (options.viewport) {
+      if (options.viewport === "mobile") viewport = { width: 375, height: 667 };
+      else if (options.viewport === "desktop") viewport = { width: 1920, height: 1080 };
+      else if (options.viewport === "tablet") viewport = { width: 768, height: 1024 };
+      else {
+        const [w, h] = options.viewport.split("x").map(Number);
+        if (w && h) viewport = { width: w, height: h };
+      }
+    }
+    scanner = new RegulatoryScanner({
+      url,
+      failOnCritical: options.ci,
+      viewport,
+      silent: options.json
+      // Suppress debug output for JSON mode
+    });
+    if (spinner) spinner.text = t("cli.analyzing");
+    const result = await scanner.scan();
+    if (spinner) spinner.succeed(t("cli.complete"));
+    if (options.pdf) {
+      if (spinner) spinner.start(t("cli.generating_pdf"));
+      const html = generateReportHTML(result);
+      await generatePDF(html, options.pdf);
+      if (spinner) spinner.succeed(t("cli.pdf_saved", { path: options.pdf }));
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(chalk.bold(t("cli.score", { score: result.score })));
+      const statusColor = result.complianceStatus === "PASS" ? chalk.green : chalk.red;
+      console.log(statusColor.bold(t("cli.status", { status: result.complianceStatus })));
+      if (result.complianceStatus === "FAIL") {
+        console.log(chalk.red(t("cli.not_compliant")));
+      }
+      console.log(chalk.gray("----------------------------------------"));
+      if (options.viewport) {
+        console.log(chalk.blue(t("cli.viewport", { width: viewport.width, height: viewport.height })));
+      }
+      if (result.htmlValidation && !result.htmlValidation.valid) {
+        console.log(chalk.red.bold("\n\u26A0\uFE0F  Structural HTML Issues Detected"));
+        console.log(chalk.yellow("    These issues may affect accessibility tool accuracy (e.g. contrast calculations)\n"));
+        result.htmlValidation.errors.forEach((error) => {
+          console.log(chalk.red(`    [${error.rule}] ${error.message}`));
+          if (error.selector) console.log(chalk.gray(`    ${error.selector}`));
+          console.log(chalk.gray(`    Line: ${error.line}, Col: ${error.column}
+`));
+        });
+        console.log(chalk.gray("----------------------------------------"));
+      }
+      result.reports.forEach((report) => {
+        const color = report.holmdigitalInsight.diggRisk === "critical" ? chalk.red : chalk.yellow;
+        console.log(color.bold(`
+[${report.holmdigitalInsight.diggRisk.toUpperCase()}] ${report.ruleId}`));
+        console.log(chalk.white(`WCAG: ${report.wcagCriteria} | EN 301 549: ${report.en301549Criteria}`));
+        console.log(chalk.gray(`Legitimitet: ${report.dosLagenReference}`));
+        if (report.remediation.component) {
+          console.log(chalk.green(t("cli.prescriptive_fix")));
+          console.log(t("cli.use_component", { component: chalk.bold(report.remediation.component) }));
+        }
+        if (report.failingNodes && report.failingNodes.length > 0) {
+          console.log(chalk.gray("\nAffected Elements:"));
+          report.failingNodes.forEach((node, index) => {
+            if (index < 5) {
+              console.log(chalk.cyan(`\u279C ${node.target}`));
+              console.log(chalk.gray(`  ${node.html}`));
+            }
+          });
+          if (report.failingNodes.length > 5) {
+            console.log(chalk.gray(`  ...and ${report.failingNodes.length - 5} more`));
+          }
+        }
+      });
+      console.log(chalk.gray("\n----------------------------------------"));
+      console.log(`Critical: ${result.stats.critical} | High: ${result.stats.high} | Medium: ${result.stats.medium} | Total: ${result.stats.total}
+`);
+      if (options.generateTests) {
+        console.log(chalk.magenta.bold(t("cli.pseudo_tests")));
+        const automation = new PseudoAutomationEngine();
+        result.reports.forEach((report) => {
+          if (report.testability.pseudoAutomation) {
+            console.log(chalk.cyan(t("cli.test_for", { ruleId: report.ruleId })));
+            console.log(chalk.gray(automation.generateTestScript(report, url)));
+          }
+        });
+      }
+    }
+    if (options.ci && result.stats.critical > 0) {
+      if (!options.json) console.error(chalk.red(t("cli.critical_failure")));
+      process.exit(1);
+    }
+    if (options.apiKey) {
+      const cloudSpinner = !options.json ? ora("Uploading results to HolmDigital Cloud...").start() : null;
+      const cloudConfig = {
+        apiKey: options.apiKey,
+        cloudUrl: options.cloudUrl
+      };
+      const cloudResponse = await sendToCloud(cloudConfig, result);
+      if (cloudResponse.success) {
+        if (cloudSpinner) cloudSpinner.succeed("Results uploaded to HolmDigital Cloud");
+        if (!options.json) {
+          console.log(chalk.green(`\u2713 ${cloudResponse.message}`));
+        }
+      } else {
+        if (cloudSpinner) cloudSpinner.fail("Cloud upload failed");
+        if (!options.json) {
+          console.error(chalk.red(`Cloud error: ${cloudResponse.error}`));
+        }
+      }
+    }
+  } catch (error) {
+    if (spinner) spinner.fail(t("cli.scan_failed"));
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("ERR_NAME_NOT_RESOLVED")) {
+      console.error(chalk.red(`Error: Could not resolve domain for '${url}'`));
+      console.error(chalk.gray("Please check that the URL is correct and the site is accessible."));
+    } else if (errorMessage.includes("ERR_CONNECTION_REFUSED")) {
+      console.error(chalk.red(`Error: Connection refused for '${url}'`));
+      console.error(chalk.gray("The server may be down or blocking automated access."));
+    } else if (errorMessage.includes("Timeout")) {
+      console.error(chalk.red(`Error: Connection timed out for '${url}'`));
+      console.error(chalk.gray("The page took too long to respond."));
+    } else {
+      console.error(chalk.red(`Error: ${errorMessage}`));
+    }
+    process.exit(1);
+  } finally {
+    if (typeof scanner !== "undefined") {
+      await scanner.close();
+    }
+  }
+});
+program.parse();

package/dist/i18n-FLJMYIKJ.mjs ADDED Viewed

@@ -0,0 +1,11 @@
+import {
+  getCurrentLang,
+  setLanguage,
+  t
+} from "./chunk-OXZPYWBW.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  getCurrentLang,
+  setLanguage,
+  t
+};

package/dist/index.d.mts ADDED Viewed

@@ -0,0 +1,88 @@
+import { RegulatoryReport } from '@holmdigital/standards';
+import { Page } from 'puppeteer';
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        rule: string;
+        message: string;
+        line: number;
+        column: number;
+        selector?: string;
+    }>;
+}
+interface ScannerOptions {
+    url: string;
+    headless?: boolean;
+    standard?: 'wcag' | 'en301549' | 'dos-lagen';
+    failOnCritical?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    silent?: boolean;
+}
+interface ScanResult {
+    url: string;
+    timestamp: string;
+    reports: RegulatoryReport[];
+    stats: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+        total: number;
+    };
+    score: number;
+    complianceStatus: 'PASS' | 'FAIL';
+    htmlValidation?: ValidationResult;
+}
+declare class RegulatoryScanner {
+    private browser;
+    private options;
+    private htmlValidator;
+    constructor(options: ScannerOptions);
+    private log;
+    scan(): Promise<ScanResult>;
+    private initBrowser;
+    private getPage;
+    private injectAxe;
+    private enrichResults;
+    private generateResultPackage;
+    close(): Promise<void>;
+}
+interface VirtualNode {
+    nodeId: string;
+    tagName: string;
+    attributes: Record<string, string>;
+    children: VirtualNode[];
+    parentId?: string;
+    isShadowRoot?: boolean;
+    shadowMode?: 'open' | 'closed';
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    computedStyle?: Record<string, string>;
+    textContent?: string;
+}
+interface VirtualDOMConfig {
+    includeComputedStyle?: string[];
+    maxDepth?: number;
+}
+declare class VirtualDOMBuilder {
+    private page;
+    constructor(page: Page);
+    build(config?: VirtualDOMConfig): Promise<VirtualNode>;
+}
+declare class PseudoAutomationEngine {
+    generateTestScript(report: RegulatoryReport, url: string): string;
+    generateManualChecklist(report: RegulatoryReport): string;
+}
+export { PseudoAutomationEngine, RegulatoryScanner, type ScanResult, type ScannerOptions, VirtualDOMBuilder, type VirtualDOMConfig, type VirtualNode };

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,88 @@
+import { RegulatoryReport } from '@holmdigital/standards';
+import { Page } from 'puppeteer';
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        rule: string;
+        message: string;
+        line: number;
+        column: number;
+        selector?: string;
+    }>;
+}
+interface ScannerOptions {
+    url: string;
+    headless?: boolean;
+    standard?: 'wcag' | 'en301549' | 'dos-lagen';
+    failOnCritical?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    silent?: boolean;
+}
+interface ScanResult {
+    url: string;
+    timestamp: string;
+    reports: RegulatoryReport[];
+    stats: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+        total: number;
+    };
+    score: number;
+    complianceStatus: 'PASS' | 'FAIL';
+    htmlValidation?: ValidationResult;
+}
+declare class RegulatoryScanner {
+    private browser;
+    private options;
+    private htmlValidator;
+    constructor(options: ScannerOptions);
+    private log;
+    scan(): Promise<ScanResult>;
+    private initBrowser;
+    private getPage;
+    private injectAxe;
+    private enrichResults;
+    private generateResultPackage;
+    close(): Promise<void>;
+}
+interface VirtualNode {
+    nodeId: string;
+    tagName: string;
+    attributes: Record<string, string>;
+    children: VirtualNode[];
+    parentId?: string;
+    isShadowRoot?: boolean;
+    shadowMode?: 'open' | 'closed';
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    computedStyle?: Record<string, string>;
+    textContent?: string;
+}
+interface VirtualDOMConfig {
+    includeComputedStyle?: string[];
+    maxDepth?: number;
+}
+declare class VirtualDOMBuilder {
+    private page;
+    constructor(page: Page);
+    build(config?: VirtualDOMConfig): Promise<VirtualNode>;
+}
+declare class PseudoAutomationEngine {
+    generateTestScript(report: RegulatoryReport, url: string): string;
+    generateManualChecklist(report: RegulatoryReport): string;
+}
+export { PseudoAutomationEngine, RegulatoryScanner, type ScanResult, type ScannerOptions, VirtualDOMBuilder, type VirtualDOMConfig, type VirtualNode };