@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-accessibility-advanced.js

@@ -0,0 +1,689 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Advanced UI Accessibility Preflight
+ *
+ * Comprehensive accessibility checks:
+ * 1. Focus Ring Consistency - Missing or inconsistent focus indicators
+ * 2. Touch Target Size - Buttons/links smaller than 44px touch target
+ * 3. ARIA Labels - Interactive elements without labels
+ * 4. Color Contrast Patterns - Known low-contrast patterns
+ * 5. Keyboard Navigation - Focus order and tab index issues
+ * 6. Screen Reader Text - Missing sr-only text for icons
+ *
+ * Usage:
+ *   pnpm preflight:ui-a11y              # All checks
+ *   pnpm preflight:ui-a11y focus        # Focus ring only
+ *   pnpm preflight:ui-a11y touch        # Touch targets only
+ *   pnpm preflight:ui-a11y aria         # ARIA labels only
+ *   pnpm preflight:ui-a11y contrast     # Color contrast only
+ *   pnpm preflight:ui-a11y keyboard     # Keyboard nav only
+ *   pnpm preflight:ui-a11y sr-text      # Screen reader text only
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIAccessibilityAdvancedModule = void 0;
+const fs = __importStar(require("fs"));
+const file_cache_1 = require("../../shared/file-cache");
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+const design_tokens_1 = require("../../shared/design-tokens");
+const EXCLUDED_PATTERNS = [
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.test.tsx",
+    "**/*.spec.tsx",
+    "**/*.stories.tsx",
+];
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class UIAccessibilityAdvancedModule {
+    verbose;
+    parallel = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    async getFiles() {
+        return await file_cache_1.fileCache.getAllTsxJsx();
+    }
+    /**
+     * 1. Focus Ring Consistency
+     * - Elements with onClick but no focus styles
+     * - Custom focus styles that don't match design system
+     * - outline: none without replacement focus indicator
+     */
+    async checkFocusRingConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for outline: none or outline: 0 without focus-visible replacement
+                if (/outline:\s*(?:none|0)/.test(line)) {
+                    const contextBlock = lines
+                        .slice(Math.max(0, index - 5), Math.min(index + 5, lines.length))
+                        .join("\n");
+                    const hasFocusVisible = /focus-visible|:focus-visible|focusVisible/.test(contextBlock);
+                    const hasRingClass = /ring-|focus:ring/.test(contextBlock);
+                    if (!hasFocusVisible && !hasRingClass) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "outline-none-no-replacement",
+                            severity: "warning",
+                            message: "outline: none without focus-visible replacement (accessibility issue)",
+                            suggestion: "Add focus-visible:ring-2 focus-visible:ring-primary or equivalent",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for clickable divs without focus handling
+                if (/<div[^>]*onClick/.test(line) || /<Box[^>]*onClick/.test(line)) {
+                    const elementBlock = lines.slice(index, Math.min(index + 10, lines.length)).join("\n");
+                    const hasTabIndex = /tabIndex/.test(elementBlock);
+                    const hasRole = /role=/.test(elementBlock);
+                    const hasFocusStyle = /focus:|:focus|onFocus/.test(elementBlock);
+                    if (!hasTabIndex && !hasRole) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "clickable-div-no-a11y",
+                            severity: "warning",
+                            message: "Clickable div/Box without tabIndex or role (not keyboard accessible)",
+                            suggestion: 'Add tabIndex={0} role="button" and onKeyDown handler',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    else if (hasTabIndex && !hasFocusStyle) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "focusable-no-focus-style",
+                            severity: "info",
+                            message: "Focusable element without visible focus style",
+                            suggestion: "Add focus:ring-2 or focus-visible styles",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Focus Ring Consistency",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. Touch Target Size
+     * - Buttons/links smaller than 44px minimum touch target
+     * - Icon buttons without adequate padding
+     */
+    async checkTouchTargetSize() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for IconButton with small size
+                if (/<IconButton[^>]*size=["']small["']/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 5, lines.length)).join("\n");
+                    const hasMinSize = /min-w-|min-h-|minWidth|minHeight/.test(contextBlock);
+                    const hasPadding = /p-[3-9]|padding/.test(contextBlock);
+                    if (!hasMinSize && !hasPadding) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "small-icon-button",
+                            severity: "info",
+                            message: `Small IconButton may not meet ${design_tokens_1.TOUCH_TARGETS.minimum}px touch target minimum`,
+                            suggestion: `Consider size="medium" or add min-w-11 min-h-11 (${design_tokens_1.TOUCH_TARGETS.minimum}px)`,
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for very small buttons (h-6, h-7, h-8 = 24-32px)
+                if (/<Button[^>]*className=["'][^"']*h-[678][^0-9]/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "small-button-height",
+                        severity: "warning",
+                        message: `Button height (${design_tokens_1.TOUCH_TARGETS.smallMin}-${design_tokens_1.TOUCH_TARGETS.smallMax}px) below ${design_tokens_1.TOUCH_TARGETS.minimum}px touch target minimum`,
+                        suggestion: `Use h-11 (${design_tokens_1.TOUCH_TARGETS.minimum}px) minimum for touch accessibility`,
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for inline links that might be too small
+                if (/<a[^>]*className=["'][^"']*text-xs/.test(line) ||
+                    /<Link[^>]*className=["'][^"']*text-xs/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 5, lines.length)).join("\n");
+                    const hasPadding = /p-[2-9]|py-|px-/.test(contextBlock);
+                    if (!hasPadding) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "small-link-text",
+                            severity: "info",
+                            message: "Small text link may have insufficient touch target",
+                            suggestion: "Add py-2 px-1 for adequate touch area",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Touch Target Size",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. ARIA Labels
+     * - Interactive elements without aria-label
+     * - Images without alt text
+     * - Form inputs without labels
+     */
+    async checkAriaLabels() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // IconButton without aria-label
+                if (/<IconButton/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 20, lines.length)).join("\n");
+                    const hasAriaLabel = /aria-label=/.test(contextBlock);
+                    const hasLabel = /\blabel=/.test(contextBlock);
+                    const hasTitle = /title=/.test(contextBlock);
+                    const hasTooltip = /Tooltip/.test(lines.slice(Math.max(0, index - 3), index).join("\n"));
+                    if (!hasAriaLabel && !hasLabel && !hasTitle && !hasTooltip) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "icon-button-no-label",
+                            severity: "warning",
+                            message: "IconButton without aria-label (screen readers cannot identify)",
+                            suggestion: 'Add aria-label="descriptive action name"',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // img without alt
+                if (/<img[^>]*(?!.*alt=)/.test(line) && !line.includes("alt=")) {
+                    const contextBlock = lines.slice(index, Math.min(index + 5, lines.length)).join("\n");
+                    if (!contextBlock.includes("alt=")) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "img-no-alt",
+                            severity: "warning",
+                            message: "Image without alt attribute",
+                            suggestion: 'Add alt="description" or alt="" for decorative images',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Input without associated label
+                if (/<input[^>]*type=["'](?:text|email|password|tel|number)["']/.test(line)) {
+                    const contextBlock = lines
+                        .slice(Math.max(0, index - 10), Math.min(index + 5, lines.length))
+                        .join("\n");
+                    const hasLabel = /<label[^>]*htmlFor=/.test(contextBlock) ||
+                        /aria-label=/.test(contextBlock) ||
+                        /aria-labelledby=/.test(contextBlock);
+                    const hasPlaceholder = /placeholder=/.test(line);
+                    if (!hasLabel && !hasPlaceholder) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "input-no-label",
+                            severity: "warning",
+                            message: "Input without label or aria-label",
+                            suggestion: 'Add <label htmlFor="id"> or aria-label',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Button with only icon (no text, no aria-label)
+                if (/<Button[^>]*>/.test(line)) {
+                    const buttonBlock = lines.slice(index, Math.min(index + 5, lines.length)).join("\n");
+                    const buttonEnd = buttonBlock.indexOf("</Button>");
+                    if (buttonEnd > 0) {
+                        const buttonContent = buttonBlock.substring(0, buttonEnd);
+                        // Check for visible text - look for text content between tags or after self-closing icon
+                        const hasText = />[\s]*[a-zA-Z]/.test(buttonContent) ||
+                            />\s*\{[^}]*\}\s*[a-zA-Z]/.test(buttonContent);
+                        const hasAriaLabel = /aria-label=/.test(buttonContent);
+                        const hasOnlyIcon = /<[A-Z][a-zA-Z]*Icon|Icon\s*\/>|lucide/.test(buttonContent);
+                        // Check for startIcon/endIcon props with text content
+                        const hasIconPropWithText = /(?:startIcon|endIcon)=/.test(buttonContent) && />\s*[a-zA-Z]/.test(buttonContent);
+                        if (hasOnlyIcon && !hasText && !hasAriaLabel && !hasIconPropWithText) {
+                            issues.push({
+                                file,
+                                line: index + 1,
+                                type: "icon-only-button-no-label",
+                                severity: "warning",
+                                message: "Button with only icon and no aria-label",
+                                suggestion: "Add aria-label or visible text",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        return {
+            name: "ARIA Labels",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. Color Contrast Patterns
+     * - Known low-contrast color combinations
+     * - Text on colored backgrounds without sufficient contrast
+     */
+    async checkColorContrastPatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        // Known problematic patterns
+        const lowContrastPatterns = [
+            { pattern: /text-gray-400/, bg: /bg-gray-100|bg-white/, name: "gray-400 on light bg" },
+            { pattern: /text-gray-300/, bg: /bg-gray-[12]00|bg-white/, name: "gray-300 on light bg" },
+            {
+                pattern: /text-\[var\(--text-tertiary\)\]/,
+                bg: /bg-white|bg-\[var\(--bg-primary\)\]/,
+                name: "tertiary text on primary bg",
+            },
+        ];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for placeholder text that might be too light
+                if (/placeholder:text-gray-[34]00/.test(line) || /placeholder-gray-[34]00/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "low-contrast-placeholder",
+                        severity: "info",
+                        message: "Placeholder text may have low contrast",
+                        suggestion: "Use placeholder:text-gray-500 minimum for WCAG AA",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for disabled states that might be too faded
+                if (/disabled:text-gray-[23]00/.test(line) || /disabled:opacity-[23]0/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "low-contrast-disabled",
+                        severity: "info",
+                        message: "Disabled state may have insufficient contrast",
+                        suggestion: "Use disabled:text-gray-400 or disabled:opacity-50 minimum",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for text on colored backgrounds
+                if (/bg-(?:blue|green|red|yellow|purple)-[1-3]00/.test(line) &&
+                    /text-(?:blue|green|red|yellow|purple)-[4-6]00/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "similar-hue-contrast",
+                        severity: "info",
+                        message: "Text and background use similar hues (may have contrast issues)",
+                        suggestion: "Use darker text (700-900) on light backgrounds",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Heuristic: header/nav often sets `text-white`; inputs with light backgrounds can inherit
+                // white text if they don't explicitly set a token-based text color.
+                // This is a common regression for top-nav search bars.
+                if (/className=\{?[^\n]*text-white/.test(line) ||
+                    /className=["'][^"']*text-white/.test(line)) {
+                    const window = lines.slice(index, Math.min(index + 140, lines.length)).join("\n");
+                    const hasLightInputSurface = /<input[\s\S]{0,300}bg-(?:white|background)\b|<input[\s\S]{0,300}bg-\[var\(--glass-bg-opaque\)\]/.test(window);
+                    const hasExplicitTokenText = /text-\[var\(--text-(?:primary|secondary|tertiary)\)\]/.test(window);
+                    if (hasLightInputSurface && !hasExplicitTokenText) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "inherited-white-text-risk",
+                            severity: "warning",
+                            message: "Possible inherited white text on a light input background (contrast risk)",
+                            suggestion: "Set input text explicitly (e.g., text-[var(--text-primary)] and placeholder:text-[var(--text-secondary)])",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Color Contrast Patterns",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Keyboard Navigation
+     * - Positive tabIndex (disrupts natural order)
+     * - Missing keyboard handlers on interactive elements
+     * - Focus traps without escape
+     */
+    async checkKeyboardNavigation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for positive tabIndex (anti-pattern)
+                const tabIndexMatch = line.match(/tabIndex=\{?["']?(\d+)["']?\}?/);
+                if (tabIndexMatch && parseInt(tabIndexMatch[1]) > 0) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "positive-tabindex",
+                        severity: "warning",
+                        message: `Positive tabIndex (${tabIndexMatch[1]}) disrupts natural tab order`,
+                        suggestion: "Use tabIndex={0} or restructure DOM order instead",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for onClick without onKeyDown on non-button elements
+                if (/<(?:div|span|Box|li|tr)[^>]*onClick/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 10, lines.length)).join("\n");
+                    const hasKeyHandler = /onKeyDown|onKeyUp|onKeyPress/.test(contextBlock);
+                    const hasRole = /role=["']button["']|role=["']link["']/.test(contextBlock);
+                    if (!hasKeyHandler && hasRole) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "click-no-keyboard",
+                            severity: "warning",
+                            message: "Element with onClick and role but no keyboard handler",
+                            suggestion: 'Add onKeyDown={(e) => e.key === "Enter" && onClick()}',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for autofocus (can be disorienting)
+                if (/autoFocus|autofocus/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "autofocus-usage",
+                        severity: "info",
+                        message: "autoFocus can be disorienting for screen reader users",
+                        suggestion: "Consider if autoFocus is necessary or use focus management",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+        }
+        return {
+            name: "Keyboard Navigation",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Screen Reader Text
+     * - Icon-only elements without sr-only text
+     * - Decorative elements not hidden from screen readers
+     */
+    async checkScreenReaderText() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Check for status indicators without text
+                if (/<(?:span|div)[^>]*className=["'][^"']*(?:bg-green|bg-red|bg-yellow|bg-blue)-[45]00[^"']*["'][^>]*\/>/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 5, lines.length)).join("\n");
+                    const hasSrOnly = /sr-only|visually-hidden/.test(contextBlock);
+                    const hasAriaLabel = /aria-label=/.test(contextBlock);
+                    if (!hasSrOnly && !hasAriaLabel) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "status-indicator-no-text",
+                            severity: "info",
+                            message: "Color-only status indicator without screen reader text",
+                            suggestion: 'Add <span className="sr-only">Status: Active</span>',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for decorative icons not hidden
+                if (/<(?:svg|img)[^>]*(?:decorative|decoration)/.test(line)) {
+                    const hasAriaHidden = /aria-hidden=["']true["']/.test(line);
+                    if (!hasAriaHidden) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "decorative-not-hidden",
+                            severity: "info",
+                            message: "Decorative element should be hidden from screen readers",
+                            suggestion: 'Add aria-hidden="true" to decorative elements',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for loading spinners without announcement
+                if (/<(?:CircularProgress|Spinner|Loading)/.test(line)) {
+                    const contextBlock = lines.slice(index, Math.min(index + 10, lines.length)).join("\n");
+                    const hasAriaLabel = /aria-label=/.test(contextBlock);
+                    const hasAriaLive = /aria-live=/.test(contextBlock);
+                    const hasSrOnly = /sr-only/.test(contextBlock);
+                    if (!hasAriaLabel && !hasAriaLive && !hasSrOnly) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "loading-no-announcement",
+                            severity: "info",
+                            message: "Loading indicator without screen reader announcement",
+                            suggestion: 'Add aria-label="Loading" or nearby sr-only text',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Screen Reader Text",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run all checks
+     */
+    async runAll() {
+        const startTime = Date.now();
+        console.log(`\n${console_chars_1.emoji.accessibility} ADVANCED UI ACCESSIBILITY PREFLIGHT`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const checks = [];
+        checks.push(await this.checkFocusRingConsistency());
+        checks.push(await this.checkTouchTargetSize());
+        checks.push(await this.checkAriaLabels());
+        checks.push(await this.checkColorContrastPatterns());
+        checks.push(await this.checkKeyboardNavigation());
+        checks.push(await this.checkScreenReaderText());
+        const totalDuration = Date.now() - startTime;
+        const allIssues = checks.flatMap((c) => c.issues);
+        const errors = allIssues.filter((i) => i.severity === "error").length;
+        const warnings = allIssues.filter((i) => i.severity === "warning").length;
+        const infos = allIssues.filter((i) => i.severity === "info").length;
+        const blockingFailed = checks.some((c) => c.blocking && !c.passed);
+        const summary = {
+            total: checks.length,
+            passed: checks.filter((c) => c.passed).length,
+            failed: checks.filter((c) => !c.passed).length,
+            errors,
+            warnings,
+        };
+        // Print results
+        checks.forEach((check) => {
+            const icon = check.passed ? `${console_chars_1.emoji.success}` : `${console_chars_1.emoji.error}`;
+            const suffix = check.blocking ? " [BLOCKING]" : "";
+            console.log(`${icon} ${check.name} (${check.issues.length} issues, ${(check.duration / 1000).toFixed(1)}s)${suffix}`);
+        });
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`Errors: ${errors} | Warnings: ${warnings} | Info: ${infos} | Time: ${(totalDuration / 1000).toFixed(1)}s`);
+        if (blockingFailed) {
+            console.log(`\n${console_chars_1.emoji.error} ACCESSIBILITY FAILED - ${errors} error(s)`);
+        }
+        else if (warnings > 0) {
+            console.log(`\n${console_chars_1.emoji.warning} ACCESSIBILITY PASSED - ${warnings} warning(s)`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} ACCESSIBILITY PASSED`);
+        }
+        return {
+            module: "ui-accessibility-advanced",
+            passed: !blockingFailed,
+            totalDuration,
+            checks,
+            summary,
+        };
+    }
+}
+exports.UIAccessibilityAdvancedModule = UIAccessibilityAdvancedModule;
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const args = process.argv.slice(2);
+    const mode = args[0] || "all";
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const parallel = args.includes("--parallel") || args.includes("-p");
+    const module = new UIAccessibilityAdvancedModule({ verbose, parallel });
+    const runSingle = async (name, fn) => {
+        console.log(`\n${console_chars_1.emoji.accessibility} ACCESSIBILITY: ${name.toUpperCase()}`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const check = await fn();
+        const summary = {
+            total: 1,
+            passed: check.passed ? 1 : 0,
+            failed: check.passed ? 0 : 1,
+            errors: check.issues.filter((i) => i.severity === "error").length,
+            warnings: check.issues.filter((i) => i.severity === "warning").length,
+        };
+        const icon = check.passed ? `${console_chars_1.emoji.success}` : `${console_chars_1.emoji.error}`;
+        console.log(`${icon} ${check.name} (${check.issues.length} issues, ${(check.duration / 1000).toFixed(1)}s)`);
+        if (check.issues.length > 0) {
+            check.issues.slice(0, 30).forEach((issue) => {
+                const color = issue.severity === "error"
+                    ? "\x1b[31m"
+                    : issue.severity === "warning"
+                        ? "\x1b[33m"
+                        : "\x1b[36m";
+                const reset = "\x1b[0m";
+                console.log(`   ${color}[${issue.severity.toUpperCase()}]${reset} ${issue.file}:${issue.line}`);
+                console.log(`   ${issue.message}`);
+                if (issue.suggestion)
+                    console.log(`   ${console_chars_1.chars.arrow} ${issue.suggestion}`);
+            });
+            if (check.issues.length > 30)
+                console.log(`   ... and ${check.issues.length - 30} more issues`);
+        }
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        return {
+            module: `ui-a11y:${name}`,
+            passed: check.passed,
+            totalDuration: check.duration,
+            checks: [check],
+            summary,
+        };
+    };
+    let result;
+    switch (mode) {
+        case "focus":
+            result = await runSingle("focus", () => module.checkFocusRingConsistency());
+            break;
+        case "touch":
+            result = await runSingle("touch", () => module.checkTouchTargetSize());
+            break;
+        case "aria":
+            result = await runSingle("aria", () => module.checkAriaLabels());
+            break;
+        case "contrast":
+            result = await runSingle("contrast", () => module.checkColorContrastPatterns());
+            break;
+        case "keyboard":
+            result = await runSingle("keyboard", () => module.checkKeyboardNavigation());
+            break;
+        case "sr-text":
+            result = await runSingle("sr-text", () => module.checkScreenReaderText());
+            break;
+        default:
+            result = await module.runAll();
+            break;
+    }
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=ui-accessibility-advanced.js.map