wcag-scanner 1.0.0 → 1.2.0

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,183 @@
+#!!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const __1 = require("..");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+// Try to load package.json for version information
+let version = '0.1.0';
+try {
+    const packagePath = path_1.default.join(__dirname, '../../package.json');
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packagePath, 'utf8'));
+    version = packageJson.version;
+}
+catch (e) {
+    // Ignore package.json load error
+}
+commander_1.program
+    .name('wcag-scanner')
+    .description('Scan HTML files and websites for WCAG accessibility violations')
+    .version(version);
+// Command to scan HTML file
+commander_1.program
+    .command('scan <filePath>')
+    .description('Scan a local HTML file for accessibility violations')
+    .option('-l, --level <level>', 'WCAG level (A, AA, AAA)', 'AA')
+    .option('-f, --format <format>', 'Output format (json, console, html)', 'console')
+    .option('-o, --output <file>', 'Save results to file')
+    .option('-v, --verbose', 'Show verbose output')
+    .option('-r, --rules <rules>', 'Comma-separated list of rules to check')
+    .action(async (filePath, options) => {
+    try {
+        console.log(`Scanning file: ${filePath}`);
+        const scannerOptions = {
+            level: options.level,
+            verbose: options.verbose || false,
+            rules: options.rules ? options.rules.split(',') : undefined
+        };
+        const results = await (0, __1.scanFile)(filePath, scannerOptions);
+        // Generate report
+        const report = (0, __1.formatReport)(results, options.format, scannerOptions);
+        // Output to console if not html format
+        if (options.format !== 'html') {
+            console.log(report);
+        }
+        // Save to file if specified
+        if (options.output) {
+            console.log(`Saving report to: ${options.output}`);
+            (0, __1.saveReport)(report, options.output);
+        }
+        // Exit with appropriate code based on violations
+        process.exit(results.violations.length > 0 ? 1 : 0);
+    }
+    catch (error) {
+        console.error('Error scanning file:', error);
+        process.exit(1);
+    }
+});
+// Command to scan URL
+commander_1.program
+    .command('url <url>')
+    .description('Scan a website URL for accessibility issues')
+    .option('-l, --level <level>', 'WCAG level (A, AA, AAA)', 'AA')
+    .option('-f, --format <format>', 'Output format (json, console, html)', 'console')
+    .option('-o, --output <file>', 'Save results to file')
+    .option('-v, --verbose', 'Show verbose output')
+    .option('-r, --rules <rules>', 'Comma-separated list of rules to check')
+    .action(async (urlString, options) => {
+    try {
+        // Add protocol if missing
+        if (!urlString.startsWith('http://') && !urlString.startsWith('https://')) {
+            urlString = 'https://' + urlString;
+            console.log(`Added protocol to URL: ${urlString}`);
+        }
+        console.log(`Scanning URL: ${urlString}`);
+        // Fetch the URL content
+        const html = await fetchUrl(urlString);
+        const scannerOptions = {
+            level: options.level,
+            verbose: options.verbose || false,
+            baseUrl: urlString,
+            rules: options.rules ? options.rules.split(',') : undefined
+        };
+        const results = await (0, __1.scanHtml)(html, scannerOptions);
+        // Generate report
+        const report = (0, __1.formatReport)(results, options.format, scannerOptions);
+        // Output to console if not html format
+        if (options.format !== 'html') {
+            console.log(report);
+        }
+        // Save to file if specified
+        if (options.output) {
+            console.log(`Saving report to: ${options.output}`);
+            (0, __1.saveReport)(report, options.output);
+        }
+        // Exit with appropriate code based on violations
+        process.exit(results.violations.length > 0 ? 1 : 0);
+    }
+    catch (error) {
+        console.error('Error scanning URL:', error);
+        process.exit(1);
+    }
+});
+// Command to scan HTML from stdin
+commander_1.program
+    .command('stdin')
+    .description('Scan HTML input from stdin')
+    .option('-l, --level <level>', 'WCAG level (A, AA, AAA)', 'AA')
+    .option('-f, --format <format>', 'Output format (json, console, html)', 'console')
+    .option('-o, --output <file>', 'Save results to file')
+    .option('-v, --verbose', 'Show verbose output')
+    .option('-r, --rules <rules>', 'Comma-separated list of rules to check')
+    .action(async (options) => {
+    try {
+        console.log('Reading HTML from stdin...');
+        let html = '';
+        process.stdin.on('data', (chunk) => {
+            html += chunk;
+        });
+        process.stdin.on('end', async () => {
+            console.log(`Received ${html.length} bytes of HTML`);
+            const scannerOptions = {
+                level: options.level,
+                verbose: options.verbose || false,
+                rules: options.rules ? options.rules.split(',') : undefined
+            };
+            const results = await (0, __1.scanHtml)(html, scannerOptions);
+            // Generate report
+            const report = (0, __1.formatReport)(results, options.format, scannerOptions);
+            // Output to console if not html format
+            if (options.format !== 'html') {
+                console.log(report);
+            }
+            // Save to file if specified
+            if (options.output) {
+                console.log(`Saving report to: ${options.output}`);
+                (0, __1.saveReport)(report, options.output);
+            }
+            // Exit with appropriate code based on violations
+            process.exit(results.violations.length > 0 ? 1 : 0);
+        });
+    }
+    catch (error) {
+        console.error('Error scanning HTML:', error);
+        process.exit(1);
+    }
+});
+// Helper function to fetch URL content
+async function fetchUrl(urlString) {
+    return new Promise((resolve, reject) => {
+        const url = new url_1.URL(urlString);
+        const client = url.protocol === 'https:' ? https_1.default : http_1.default;
+        const req = client.get(urlString, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Request failed with status code ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                resolve(data);
+            });
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+}
+// If no arguments provided, show help
+if (process.argv.length <= 2) {
+    commander_1.program.help();
+}
+// Parse command line arguments
+commander_1.program.parse(process.argv);

package/dist/index.d.ts

@@ -1,18 +1,56 @@
-import { WCAGScanner } from "./scanner";
-import { ScannerOptions, ScanResults } from "./types";
+import { WCAGScanner } from './scanner';
+import { ScannerOptions, ScanResults } from './types';
+import { ReporterFormat } from './reporters';
+import middleware from './middleware';
 /**
  * Scan HTML string for WCAG violations
  * @param html HTML content to scan
  * @param options Scanner options
- * @return Promise<ScanResults> Scan results
+ * @returns Promise<ScanResults> Scan results
  */
-export declare function scanHTML(html: string, options?: ScannerOptions): Promise<ScanResults>;
+export declare function scanHtml(html: string, options?: ScannerOptions): Promise<ScanResults>;
 /**
  * Scan HTML file for WCAG violations
  * @param filePath Path to HTML file
  * @param options Scanner options
- * @return Promise<ScanResults> Scan results
+ * @returns Promise<ScanResults> Scan results
  */
 export declare function scanFile(filePath: string, options?: ScannerOptions): Promise<ScanResults>;
+/**
+ * Scan a URL for WCAG violations
+ * @param urlString URL to scan
+ * @param options Scanner options
+ * @returns Promise<ScanResults> Scan results
+ */
+export declare function scanUrl(urlString: string, options?: ScannerOptions): Promise<ScanResults>;
+/**
+ * Generate a report from scan results
+ * @param results Scan results
+ * @param format Report format
+ * @param options Scanner options
+ * @returns Report string
+ */
+export declare function formatReport(results: ScanResults, format?: ReporterFormat, options?: ScannerOptions): string;
+/**
+ * Save report to a file
+ * @param report Report string
+ * @param filePath Output file path
+ */
+export declare function saveReport(report: string, filePath: string): void;
 export { WCAGScanner };
-export * from "./types";
+export * from './types';
+export { ReporterFormat };
+export { middleware };
+declare const _default: {
+    scanHtml: typeof scanHtml;
+    scanFile: typeof scanFile;
+    scanUrl: typeof scanUrl;
+    formatReport: typeof formatReport;
+    saveReport: typeof saveReport;
+    middleware: {
+        express: {
+            createMiddleware: typeof import("./middleware/express").createMiddleware;
+        };
+    };
+};
+export default _default;

package/dist/index.js

@@ -17,20 +17,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WCAGScanner = void 0;
-exports.scanHTML = scanHTML;
+exports.middleware = exports.WCAGScanner = void 0;
+exports.scanHtml = scanHtml;
 exports.scanFile = scanFile;
+exports.scanUrl = scanUrl;
+exports.formatReport = formatReport;
+exports.saveReport = saveReport;
 const scanner_1 = require("./scanner");
 Object.defineProperty(exports, "WCAGScanner", { enumerable: true, get: function () { return scanner_1.WCAGScanner; } });
+const reporters_1 = require("./reporters");
+const middleware_1 = __importDefault(require("./middleware"));
+exports.middleware = middleware_1.default;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
 /**
  * Scan HTML string for WCAG violations
  * @param html HTML content to scan
  * @param options Scanner options
- * @return Promise<ScanResults> Scan results
+ * @returns Promise<ScanResults> Scan results
  */
-async function scanHTML(html, options = {}) {
+async function scanHtml(html, options = {}) {
     const scanner = new scanner_1.WCAGScanner(options);
     await scanner.loadHTML(html);
     return scanner.scan();
@@ -39,7 +48,7 @@ async function scanHTML(html, options = {}) {
  * Scan HTML file for WCAG violations
  * @param filePath Path to HTML file
  * @param options Scanner options
- * @return Promise<ScanResults> Scan results
+ * @returns Promise<ScanResults> Scan results
  */
 async function scanFile(filePath, options = {}) {
     const html = fs_1.default.readFileSync(path_1.default.resolve(filePath), 'utf8');
@@ -48,4 +57,77 @@ async function scanFile(filePath, options = {}) {
     await scanner.loadHTML(html, baseUrl);
     return scanner.scan();
 }
+/**
+ * Scan a URL for WCAG violations
+ * @param urlString URL to scan
+ * @param options Scanner options
+ * @returns Promise<ScanResults> Scan results
+ */
+async function scanUrl(urlString, options = {}) {
+    // Add protocol if missing
+    if (!urlString.startsWith('http://') && !urlString.startsWith('https://')) {
+        urlString = 'https://' + urlString;
+    }
+    const html = await fetchUrl(urlString);
+    const scannerOptions = {
+        ...options,
+        baseUrl: urlString
+    };
+    return scanHtml(html, scannerOptions);
+}
+/**
+ * Generate a report from scan results
+ * @param results Scan results
+ * @param format Report format
+ * @param options Scanner options
+ * @returns Report string
+ */
+function formatReport(results, format = 'json', options = {}) {
+    return (0, reporters_1.generateReport)(results, format, options);
+}
+/**
+ * Save report to a file
+ * @param report Report string
+ * @param filePath Output file path
+ */
+function saveReport(report, filePath) {
+    fs_1.default.writeFileSync(filePath, report);
+}
+/**
+ * Helper function to fetch URL content
+ * @param urlString URL to fetch
+ * @returns Promise<string> HTML content
+ */
+async function fetchUrl(urlString) {
+    return new Promise((resolve, reject) => {
+        const url = new url_1.URL(urlString);
+        const client = url.protocol === 'https:' ? https_1.default : http_1.default;
+        const req = client.get(urlString, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Request failed with status code ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                resolve(data);
+            });
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+}
 __exportStar(require("./types"), exports);
+// Default export with all main functions
+exports.default = {
+    scanHtml,
+    scanFile,
+    scanUrl,
+    formatReport,
+    saveReport,
+    middleware: middleware_1.default
+};

package/dist/middleware/express.d.ts

@@ -0,0 +1,25 @@
+import { Request, Response, NextFunction } from 'express';
+import { ScannerOptions, ScanResults } from '../index';
+/**
+ * Options for the Express middleware
+ */
+export interface ExpressMiddlewareOptions extends ScannerOptions {
+    /** Enable/disable the middleware */
+    enabled?: boolean;
+    /** Custom header name for violation count */
+    headerName?: string;
+    /** Add inline report to HTML responses */
+    inlineReport?: boolean;
+    /** Callback function to handle violations */
+    onViolation?: (results: ScanResults, req: Request, res: Response) => void;
+}
+/**
+ * Create Express middleware for scanning HTML responses for accessibility issues
+ * @param options Middleware options
+ * @returns Express middleware function
+ */
+export declare function createMiddleware(options?: ExpressMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+declare const _default: {
+    createMiddleware: typeof createMiddleware;
+};
+export default _default;

package/dist/middleware/express.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMiddleware = createMiddleware;
+const index_1 = require("../index");
+/**
+ * Create Express middleware for scanning HTML responses for accessibility issues
+ * @param options Middleware options
+ * @returns Express middleware function
+ */
+function createMiddleware(options = {}) {
+    const defaultOptions = {
+        enabled: process.env.NODE_ENV !== 'production', // Disable in production by default
+        level: 'AA',
+        headerName: 'X-WCAG-Violations',
+        inlineReport: false,
+        ...options
+    };
+    return async function wcagScannerMiddleware(req, res, next) {
+        // Skip if disabled or non-HTML request
+        if (!defaultOptions.enabled || !shouldProcessRequest(req)) {
+            return next();
+        }
+        // Store original send method
+        const originalSend = res.send;
+        // Override send method to intercept HTML responses
+        res.send = function (body) {
+            // Only process HTML responses
+            if (typeof body === 'string' && isHtmlResponse(res)) {
+                try {
+                    // Create scanner
+                    const scanner = new index_1.WCAGScanner(defaultOptions);
+                    // Run scan asynchronously (we can't make res.send async)
+                    scanner.loadHTML(body).then(() => {
+                        return scanner.scan();
+                    }).then((results) => {
+                        // Add violation count header
+                        res.setHeader(defaultOptions.headerName || 'X-WCAG-Violations', results.violations.length.toString());
+                        // Call violation handler if provided
+                        if (defaultOptions.onViolation && results.violations.length > 0) {
+                            defaultOptions.onViolation(results, req, res);
+                        }
+                        // Add inline report if enabled
+                        if (defaultOptions.inlineReport && results.violations.length > 0) {
+                            body = insertInlineReport(body, results);
+                        }
+                        // Send modified response
+                        originalSend.call(res, body);
+                    }).catch((error) => {
+                        console.error('Error in WCAG scanner middleware:', error);
+                        // Send original response if there's an error
+                        originalSend.call(res, body);
+                    });
+                    // Return a dummy response to prevent Express from sending twice
+                    return res;
+                }
+                catch (error) {
+                    console.error('Error in WCAG scanner middleware:', error);
+                }
+            }
+            // Call original send for non-HTML responses
+            return originalSend.call(this, body);
+        };
+        next();
+    };
+}
+/**
+ * Determine if the request should be processed
+ * @param req Express request object
+ * @returns True if request should be processed
+ */
+function shouldProcessRequest(req) {
+    // Skip non-GET requests
+    if (req.method !== 'GET') {
+        return false;
+    }
+    // Skip API routes
+    if (req.path.startsWith('/api/')) {
+        return false;
+    }
+    // Skip if client doesn't want HTML
+    const accept = req.headers.accept || '';
+    if (!accept.includes('html') && !accept.includes('*/*')) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Check if response is HTML
+ * @param res Express response object
+ * @returns True if response is HTML
+ */
+function isHtmlResponse(res) {
+    const contentType = res.get('Content-Type') || '';
+    return contentType.includes('html');
+}
+/**
+ * Insert inline accessibility report into HTML
+ * @param html Original HTML
+ * @param results Scan results
+ * @returns HTML with inline report
+ */
+function insertInlineReport(html, results) {
+    // Skip if no violations
+    if (results.violations.length === 0) {
+        return html;
+    }
+    // Create simple inline report
+    const report = `
+    <div id="wcag-scanner-report" style="
+      position: fixed;
+      bottom: 20px;
+      right: 20px;
+      z-index: 9999;
+      background: white;
+      border: 2px solid #e53935;
+      border-radius: 8px;
+      padding: 20px;
+      max-width: 400px;
+      max-height: 80vh;
+      overflow: auto;
+      box-shadow: 0 0 10px rgba(0,0,0,0.2);
+      font-family: sans-serif;
+      color: #333;
+    ">
+      <div style="
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 15px;
+        border-bottom: 1px solid #eee;
+        padding-bottom: 10px;
+      ">
+        <h3 style="margin: 0; color: #e53935;">
+          ${results.violations.length} Accessibility Issues Found
+        </h3>
+        <button onclick="document.getElementById('wcag-scanner-report').style.display='none'" style="
+          background: #f5f5f5;
+          border: none;
+          border-radius: 4px;
+          padding: 5px 10px;
+          cursor: pointer;
+        ">
+          Close
+        </button>
+      </div>
+      
+      <ul style="
+        list-style-type: none;
+        padding: 0;
+        margin: 0;
+      ">
+        ${results.violations.slice(0, 5).map(violation => `
+          <li style="
+            margin-bottom: 15px;
+            padding-bottom: 15px;
+            border-bottom: 1px solid #eee;
+          ">
+            <div style="
+              font-weight: bold;
+              margin-bottom: 5px;
+            ">
+              ${violation.description}
+            </div>
+            ${violation.help ? `
+              <div style="
+                font-size: 14px;
+                margin-bottom: 8px;
+              ">
+                ${violation.help}
+              </div>
+            ` : ''}
+            ${violation.element ? `
+              <div style="
+                font-size: 13px;
+                color: #666;
+              ">
+                ${violation.element.tagName}
+                ${violation.element.id ? `#${violation.element.id}` : ''}
+              </div>
+            ` : ''}
+          </li>
+        `).join('')}
+        ${results.violations.length > 5 ? `
+          <li style="text-align: center; font-size: 14px; color: #666;">
+            +${results.violations.length - 5} more issues
+          </li>
+        ` : ''}
+      </ul>
+      <div style="
+        margin-top: 15px;
+        font-size: 12px;
+        text-align: right;
+        color: #666;
+      ">
+        Generated by WCAG Scanner
+      </div>
+    </div>
+  `;
+    // Insert before </body> if it exists, otherwise append to the end
+    if (html.includes('</body>')) {
+        return html.replace('</body>', `${report}</body>`);
+    }
+    else {
+        return html + report;
+    }
+}
+exports.default = {
+    createMiddleware
+};

package/dist/middleware/index.d.ts

@@ -0,0 +1,8 @@
+import express from './express';
+export { express };
+declare const _default: {
+    express: {
+        createMiddleware: typeof import("./express").createMiddleware;
+    };
+};
+export default _default;

package/dist/middleware/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.express = void 0;
+const express_1 = __importDefault(require("./express"));
+exports.express = express_1.default;
+exports.default = {
+    express: express_1.default
+};

package/dist/reporters/console.d.ts

@@ -0,0 +1,12 @@
+import { ScanResults, ScannerOptions } from "../types";
+/**
+ * Format scan results for console output
+ * @param results Scanner results object
+ * @param options Options used for the scan
+ * @returns Formatted console output string
+ */
+export declare function format(results: ScanResults, options?: ScannerOptions): string;
+declare const _default: {
+    format: typeof format;
+};
+export default _default;