a11yanalyze/dist/scoring/accessibility-scorer.d.ts

A command-line tool for developers and QA engineers to test web pages and websites for WCAG 2.2 AA accessibility compliance

import { ScanResult } from '../types';
import { WCAGLevel } from '../types/wcag';
import { CrawlSession } from '../types/crawler';
/**
 * Scoring algorithm configuration
 */
export interface ScoringConfig {
    /** Scoring profile to use */
    profile: ScoringProfile;
    /** WCAG level weights (higher = more important) */
    wcagLevelWeights: Record<WCAGLevel, number>;
    /** Severity penalty multipliers */
    severityPenalties: Record<string, number>;
    /** Maximum penalty per issue type */
    maxPenaltyPerIssue: number;
    /** Minimum possible score */
    minScore: number;
    /** Maximum possible score */
    maxScore: number;
    /** Enable bonus scoring */
    enableBonuses: boolean;
    /** Enable penalty systems */
    enablePenalties: boolean;
    /** Scoring transparency level */
    transparencyLevel: 'basic' | 'detailed' | 'debug';
}
/**
 * Predefined scoring profiles for different use cases
 */
export type ScoringProfile = 'strict' | 'balanced' | 'lenient' | 'enterprise' | 'custom';
/**
 * Detailed score breakdown for transparency
 */
export interface ScoreBreakdown {
    /** Final calculated score */
    finalScore: number;
    /** Base score before adjustments */
    baseScore: number;
    /** Issue-based deductions */
    issueDeductions: IssueDeduction[];
    /** Performance bonuses applied */
    bonuses: ScoreBonus[];
    /** System penalties applied */
    penalties: ScorePenalty[];
    /** Coverage assessment */
    coverage: CoverageAssessment;
    /** Calculation metadata */
    metadata: ScoreMetadata;
}
/**
 * Individual issue deduction details
 */
export interface IssueDeduction {
    /** Issue ID */
    issueId: string;
    /** WCAG reference */
    wcagReference: string;
    /** Issue severity */
    severity: string;
    /** WCAG level */
    level: WCAGLevel;
    /** Points deducted */
    pointsDeducted: number;
    /** Weight applied */
    weight: number;
    /** Reason for deduction */
    reason: string;
}
/**
 * Bonus points awarded
 */
export interface ScoreBonus {
    /** Bonus type */
    type: 'performance' | 'coverage' | 'bestPractices' | 'accessibility';
    /** Points awarded */
    points: number;
    /** Description */
    description: string;
    /** Criteria met */
    criteria: string;
}
/**
 * System penalties applied
 */
export interface ScorePenalty {
    /** Penalty type */
    type: 'timeout' | 'error' | 'coverage' | 'critical';
    /** Points deducted */
    points: number;
    /** Description */
    description: string;
    /** Affected element/area */
    affectedArea?: string;
}
/**
 * Coverage assessment details
 */
export interface CoverageAssessment {
    /** Percentage of page successfully tested */
    testCoverage: number;
    /** Total elements on page */
    totalElements: number;
    /** Elements successfully tested */
    testedElements: number;
    /** Elements that failed to test */
    failedElements: number;
    /** Coverage quality score */
    qualityScore: number;
    /** Areas not covered */
    uncoveredAreas: string[];
}
/**
 * Score calculation metadata
 */
export interface ScoreMetadata {
    /** Scoring algorithm version */
    algorithmVersion: string;
    /** Profile used */
    profile: ScoringProfile;
    /** Calculation timestamp */
    calculatedAt: string;
    /** Total calculation time (ms) */
    calculationTime: number;
    /** Configuration checksum */
    configChecksum: string;
}
/**
 * Site-wide scoring aggregation
 */
export interface SiteScore {
    /** Overall site score */
    overallScore: number;
    /** Individual page scores */
    pageScores: PageScore[];
    /** Aggregation method used */
    aggregationMethod: 'weighted' | 'average' | 'median' | 'worst';
    /** Site-wide bonuses/penalties */
    siteWideBonuses: ScoreBonus[];
    /** Score distribution statistics */
    distribution: ScoreDistribution;
    /** Consistency metrics */
    consistency: ConsistencyMetrics;
}
/**
 * Individual page score summary
 */
export interface PageScore {
    /** Page URL */
    url: string;
    /** Page score */
    score: number;
    /** Page weight in site calculation */
    weight: number;
    /** Issues contributing to score */
    issueCount: number;
    /** Page importance level */
    importance: 'critical' | 'high' | 'medium' | 'low';
}
/**
 * Score distribution across site
 */
export interface ScoreDistribution {
    /** Average score */
    average: number;
    /** Median score */
    median: number;
    /** Minimum score */
    minimum: number;
    /** Maximum score */
    maximum: number;
    /** Standard deviation */
    standardDeviation: number;
    /** Score ranges */
    ranges: {
        excellent: number;
        good: number;
        fair: number;
        poor: number;
        critical: number;
    };
}
/**
 * Site consistency metrics
 */
export interface ConsistencyMetrics {
    /** Consistency score (0-100) */
    consistencyScore: number;
    /** Pages with scores significantly below average */
    outlierPages: string[];
    /** Most common issues across site */
    commonIssues: string[];
    /** Score variance between pages */
    scoreVariance: number;
}
/**
 * Comprehensive accessibility scoring algorithm
 */
export declare class AccessibilityScorer {
    private config;
    private static readonly SCORING_PROFILES;
    constructor(config?: Partial<ScoringConfig>);
    /**
     * Calculate accessibility score for a single page
     */
    calculatePageScore(scanResult: ScanResult): ScoreBreakdown;
    /**
     * Calculate site-wide accessibility score
     */
    calculateSiteScore(crawlSession: CrawlSession, scanResults: ScanResult[], aggregationMethod?: SiteScore['aggregationMethod']): SiteScore;
    /**
     * Get scoring configuration
     */
    getConfig(): ScoringConfig;
    /**
     * Update scoring configuration
     */
    updateConfig(newConfig: Partial<ScoringConfig>): void;
    /**
     * Calculate issue deductions
     * @private
     */
    private calculateIssueDeductions;
    /**
     * Calculate performance and quality bonuses
     * @private
     */
    private calculateBonuses;
    /**
     * Calculate system penalties
     * @private
     */
    private calculatePenalties;
    /**
     * Assess test coverage quality
     * @private
     */
    private assessCoverage;
    /**
     * Helper methods for scoring calculations
     * @private
     */
    private getIssueTypeMultiplier;
    private calculatePageWeight;
    private determinePageImportance;
    private isImportantPage;
    private aggregateScores;
    private calculateSiteWideBonuses;
    private calculateScoreDistribution;
    private calculateConsistencyMetrics;
    private calculateVariance;
    private identifyUncoveredAreas;
    private mergeWithProfile;
    private generateConfigChecksum;
    /**
     * Static utility methods
     */
    /**
     * Get all available scoring profiles
     */
    static getAvailableProfiles(): ScoringProfile[];
    /**
     * Get profile configuration
     */
    static getProfileConfig(profile: ScoringProfile): Partial<ScoringConfig>;
    /**
     * Create scorer with predefined profile
     */
    static withProfile(profile: ScoringProfile, overrides?: Partial<ScoringConfig>): AccessibilityScorer;
}
//# sourceMappingURL=accessibility-scorer.d.ts.map