@uuv/a11y/dist/lib/model/result.js

A javascript lib for running a11y validation based on multiple reference(RGAA, etc)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.A11yResult = exports.A11yRuleResult = exports.A11yRuleValidationResult = exports.A11yResultStatus = void 0;
var A11yResultStatus;
(function (A11yResultStatus) {
    A11yResultStatus["UNKNOWN"] = "unknown";
    A11yResultStatus["SUCCESS"] = "success";
    A11yResultStatus["MANUAL"] = "manual";
    A11yResultStatus["ERROR"] = "error";
})(A11yResultStatus || (exports.A11yResultStatus = A11yResultStatus = {}));
class A11yRuleValidationResult {
    criteria;
    status = A11yResultStatus.UNKNOWN;
    errorNodes = [];
    nodesToCheckManually = [];
    constructor(criteria) {
        this.criteria = criteria;
    }
}
exports.A11yRuleValidationResult = A11yRuleValidationResult;
class A11yRuleResult {
    url;
    rule;
    status = A11yResultStatus.UNKNOWN;
    validations = [];
    constructor(url, rule) {
        this.url = url;
        this.rule = rule;
    }
    getOrAddValidation(criteria) {
        let validation = this.validations.find(value => value.criteria === criteria);
        if (!validation) {
            validation = new A11yRuleValidationResult(criteria);
            this.validations.push(validation);
        }
        return validation;
    }
    getErrorNodes() {
        let nodeFound = [];
        this.validations.forEach(validation => {
            nodeFound = nodeFound.concat(validation.errorNodes);
        });
        return nodeFound;
    }
    getNodesToCheckManually() {
        let nodeFound = [];
        this.validations.forEach(validation => {
            nodeFound = nodeFound.concat(validation.nodesToCheckManually);
        });
        return nodeFound;
    }
    computeStatus() {
        this.status = this.getStatus();
    }
    getStatus() {
        if (this.validations.find(validation => validation.status === A11yResultStatus.UNKNOWN)) {
            return A11yResultStatus.UNKNOWN;
        }
        if (this.validations.find(validation => validation.status === A11yResultStatus.ERROR)) {
            return A11yResultStatus.ERROR;
        }
        if (this.validations.find(validation => validation.status === A11yResultStatus.MANUAL)) {
            return A11yResultStatus.MANUAL;
        }
        return A11yResultStatus.SUCCESS;
    }
}
exports.A11yRuleResult = A11yRuleResult;
class A11yResult {
    url;
    reference;
    status = A11yResultStatus.UNKNOWN;
    ruleResults = [];
    constructor(url, reference) {
        this.url = url;
        this.reference = reference;
    }
    computeStatus() {
        this.status = computeStatus(this.ruleResults);
    }
    summary() {
        const summary = {
            status: this.status,
            criteria: {}
        };
        this.groupRuleResultByCriterion().forEach((rulesResult, key) => {
            summary.criteria[key] = this.buildSummaryForCriterion(key, rulesResult);
        });
        return summary;
    }
    buildSummaryForCriterion(criterion, criterionRulesResult) {
        const criterionSummary = {
            status: computeStatus(criterionRulesResult),
            tests: {}
        };
        this.groupRuleResultByTestOfACriterion(criterion).forEach((rulesResult, key) => {
            criterionSummary.tests[key] = {
                status: computeStatus(rulesResult)
            };
        });
        return criterionSummary;
    }
    getPosition(inputString, subString, index) {
        return inputString.split(subString, index).join(subString).length;
    }
    groupRuleResultByLevel(ruleResults, level) {
        const ruleResultPerCriteria = new Map();
        ruleResults.forEach(ruleResult => {
            const key = this.getKeyOfLevel(ruleResult, level);
            if (!ruleResultPerCriteria.has(key)) {
                ruleResultPerCriteria.set(key, []);
            }
            ruleResultPerCriteria.get(key)?.push(ruleResult);
        });
        return ruleResultPerCriteria;
    }
    getKeyOfLevel(ruleResult, level) {
        const nextLevelPosition = this.getPosition(ruleResult.rule.id, ".", level + 1);
        return ruleResult.rule.id.substring(0, nextLevelPosition > 0 ? nextLevelPosition : undefined);
    }
    groupRuleResultByCriterion() {
        return this.groupRuleResultByLevel(this.ruleResults, 1);
    }
    groupRuleResultByTestOfACriterion(criterion) {
        return this.groupRuleResultByLevel(this.ruleResults.filter(ruleResult => criterion === this.getKeyOfLevel(ruleResult, 1)), 2);
    }
}
exports.A11yResult = A11yResult;
const computeStatus = (ruleResults) => {
    ruleResults.forEach(ruleResult => ruleResult.computeStatus());
    return getStatus(ruleResults);
};
const getStatus = (ruleResults) => {
    if (ruleResults.find(ruleResult => ruleResult.status === A11yResultStatus.UNKNOWN)) {
        return A11yResultStatus.UNKNOWN;
    }
    if (ruleResults.find(ruleResult => ruleResult.status === A11yResultStatus.ERROR)) {
        return A11yResultStatus.ERROR;
    }
    if (ruleResults.find(ruleResult => ruleResult.status === A11yResultStatus.MANUAL)) {
        return A11yResultStatus.MANUAL;
    }
    return A11yResultStatus.SUCCESS;
};