@uuv/a11y 0.0.1

package/dist/lib/model/result.js

@@ -0,0 +1,144 @@
+"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 || (exports.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;
+};

package/dist/lib/model/rule.d.ts

@@ -0,0 +1,99 @@
+import { Query } from "../query/00-query";
+export interface A11yRule {
+    attributes: string[];
+    reference: string;
+    check: RuleCheckEnum;
+    criterion: string;
+    wcag: string;
+    id: string;
+    elementType: string;
+    query: Query;
+    description?: string;
+    help?: string | string[];
+    shouldNotExist: boolean;
+}
+export declare class AutoCheckA11yRule implements A11yRule {
+    attributes: string[];
+    reference: string;
+    check: RuleCheckEnum;
+    criterion: string;
+    wcag: string;
+    id: string;
+    elementType: string;
+    query: Query;
+    description?: string;
+    help?: string | string[];
+    shouldNotExist: boolean;
+    static from(input: {
+        attributes?: string[];
+        reference: string;
+        criterion: string;
+        wcag: string;
+        id: string;
+        elementType: string;
+        query: Query;
+        description?: string;
+        help?: string | string[];
+        shouldNotExist?: boolean;
+    }): AutoCheckA11yRule & {
+        attributes?: string[] | undefined;
+        reference: string;
+        criterion: string;
+        wcag: string;
+        id: string;
+        elementType: string;
+        query: Query;
+        description?: string | undefined;
+        help?: string | string[] | undefined;
+        shouldNotExist?: boolean | undefined;
+    };
+}
+export declare class ManualCheckA11yRule implements A11yRule {
+    attributes: string[];
+    reference: string;
+    check: RuleCheckEnum;
+    criterion: string;
+    wcag: string;
+    id: string;
+    elementType: string;
+    query: Query;
+    description?: string;
+    help?: string | string[];
+    shouldNotExist: boolean;
+    static from(input: {
+        attributes?: string[];
+        reference: string;
+        criterion: string;
+        wcag: string;
+        id: string;
+        elementType: string;
+        query: Query;
+        description?: string;
+        help?: string;
+        shouldNotExist?: boolean;
+    }): ManualCheckA11yRule & {
+        attributes?: string[] | undefined;
+        reference: string;
+        criterion: string;
+        wcag: string;
+        id: string;
+        elementType: string;
+        query: Query;
+        description?: string | undefined;
+        help?: string | undefined;
+        shouldNotExist?: boolean | undefined;
+    };
+}
+export declare enum RuleCheckEnum {
+    MANUAL = "MANUAL",
+    AUTO = "AUTO"
+}
+export declare enum CustomFilter {
+    DOCTYPE = "$DOCTYPE",
+    FORM_FIELD = "$FORMFIELD"
+}
+export declare enum RuleTypeEnum {
+    TAG = "TAG",
+    ROLE = "ROLE",
+    COLOR = "COLOR"
+}

package/dist/lib/model/rule.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleTypeEnum = exports.CustomFilter = exports.RuleCheckEnum = exports.ManualCheckA11yRule = exports.AutoCheckA11yRule = void 0;
+class AutoCheckA11yRule {
+    attributes;
+    reference;
+    check = RuleCheckEnum.AUTO;
+    criterion;
+    wcag;
+    id;
+    elementType;
+    query;
+    description;
+    help;
+    shouldNotExist = true;
+    static from(input) {
+        return Object.assign(new AutoCheckA11yRule(), input);
+    }
+}
+exports.AutoCheckA11yRule = AutoCheckA11yRule;
+class ManualCheckA11yRule {
+    attributes = [];
+    reference;
+    check = RuleCheckEnum.MANUAL;
+    criterion;
+    wcag;
+    id;
+    elementType;
+    query;
+    description;
+    help;
+    shouldNotExist = true;
+    static from(input) {
+        return Object.assign(new ManualCheckA11yRule(), input);
+    }
+}
+exports.ManualCheckA11yRule = ManualCheckA11yRule;
+var RuleCheckEnum;
+(function (RuleCheckEnum) {
+    RuleCheckEnum["MANUAL"] = "MANUAL";
+    RuleCheckEnum["AUTO"] = "AUTO";
+})(RuleCheckEnum = exports.RuleCheckEnum || (exports.RuleCheckEnum = {}));
+var CustomFilter;
+(function (CustomFilter) {
+    CustomFilter["DOCTYPE"] = "$DOCTYPE";
+    CustomFilter["FORM_FIELD"] = "$FORMFIELD";
+})(CustomFilter = exports.CustomFilter || (exports.CustomFilter = {}));
+var RuleTypeEnum;
+(function (RuleTypeEnum) {
+    RuleTypeEnum["TAG"] = "TAG";
+    RuleTypeEnum["ROLE"] = "ROLE";
+    RuleTypeEnum["COLOR"] = "COLOR";
+})(RuleTypeEnum = exports.RuleTypeEnum || (exports.RuleTypeEnum = {}));

package/dist/lib/query/00-query.d.ts

@@ -0,0 +1,4 @@
+export interface Query {
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/00-query.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/query/accessible-name.query.d.ts

@@ -0,0 +1,8 @@
+import { Query } from "./00-query";
+export declare class AccessibleNameQuery implements Query {
+    readonly subQuery: Query;
+    readonly shouldBeEmpty: boolean;
+    constructor(subQuery: Query, shouldBeEmpty: boolean);
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/accessible-name.query.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessibleNameQuery = void 0;
+const dom_accessibility_api_1 = require("dom-accessibility-api");
+const lodash_1 = __importDefault(require("lodash"));
+class AccessibleNameQuery {
+    subQuery;
+    shouldBeEmpty;
+    constructor(subQuery, shouldBeEmpty) {
+        this.subQuery = subQuery;
+        this.shouldBeEmpty = shouldBeEmpty;
+    }
+    execute() {
+        return this.subQuery.execute().filter(element => {
+            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element);
+            if (this.shouldBeEmpty && lodash_1.default.isEmpty(accessibleName)) {
+                return true;
+            }
+            else if (!this.shouldBeEmpty && !lodash_1.default.isEmpty(accessibleName)) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    getSelector() {
+        return `AccessibleName: ${this.subQuery.getSelector()}`;
+    }
+}
+exports.AccessibleNameQuery = AccessibleNameQuery;

package/dist/lib/query/by-role.query.d.ts

@@ -0,0 +1,8 @@
+import { Query } from "./00-query";
+export declare class ByRoleQuery implements Query {
+    readonly role: string;
+    readonly attributes: string[];
+    constructor(role: string, attributes?: string[]);
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/by-role.query.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByRoleQuery = void 0;
+const dom_1 = require("@testing-library/dom");
+class ByRoleQuery {
+    role;
+    attributes;
+    constructor(role, attributes = []) {
+        this.role = role;
+        this.attributes = attributes;
+    }
+    execute() {
+        return (0, dom_1.queryAllByRole)(window.document.documentElement, this.role)
+            ?.filter((element) => {
+            if (this.attributes.length == 0) {
+                return true;
+            }
+            return this.attributes.filter(value => {
+                return element.getAttribute(value);
+            }).length > 0;
+        });
+    }
+    getSelector() {
+        return `ByRole(${this.role}, ${this.attributes})`;
+    }
+}
+exports.ByRoleQuery = ByRoleQuery;

package/dist/lib/query/by-tag.query.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "./00-query";
+export declare class ByTagQuery implements Query {
+    readonly selectors: string[];
+    constructor(selectors: string[]);
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/by-tag.query.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByTagQuery = void 0;
+const jquery_1 = __importDefault(require("jquery"));
+class ByTagQuery {
+    selectors;
+    constructor(selectors) {
+        this.selectors = selectors;
+    }
+    execute() {
+        return (0, jquery_1.default)(this.selectors.join(",")).toArray();
+    }
+    getSelector() {
+        return `${this.selectors}`;
+    }
+}
+exports.ByTagQuery = ByTagQuery;

package/dist/lib/query/doctype.query.d.ts

@@ -0,0 +1,5 @@
+import { Query } from "./00-query";
+export declare class DoctypeQuery implements Query {
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/doctype.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctypeQuery = void 0;
+class DoctypeQuery {
+    execute() {
+        if (document?.doctype?.name !== "html") {
+            return [document.documentElement];
+        }
+        return [];
+    }
+    getSelector() {
+        return "doctype";
+    }
+}
+exports.DoctypeQuery = DoctypeQuery;

package/dist/lib/query/form.query.d.ts

@@ -0,0 +1,8 @@
+import { Query } from "./00-query";
+export declare class FormQuery implements Query {
+    LABEL_ATTRIBUTE: string;
+    FORMFIELD_SELECTORS: string[];
+    FORMFIELD_LABEL_ATTRIBUTES: string[];
+    execute(): HTMLElement[];
+    getSelector(): string;
+}

package/dist/lib/query/form.query.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormQuery = void 0;
+class FormQuery {
+    LABEL_ATTRIBUTE = "$LABEL";
+    FORMFIELD_SELECTORS = [
+        "input[type=text]",
+        "input[type=password]",
+        "input[type=search]",
+        "input[type=email]",
+        "input[type=number]",
+        "input[type=tel]",
+        "input[type=url]",
+        "textarea",
+        "input[type=checkbox]",
+        "input[type=radio]",
+        "input[type=date]",
+        "input[type=range]",
+        "input[type=color]",
+        "input[type=time]",
+        "input[type=month]",
+        "input[type=week]",
+        "input[type=datetime]",
+        "select",
+        "datalist",
+        "optgroup",
+        "option",
+        "input[type=file]",
+        "output",
+        "progress",
+        "meter",
+        "progressbar",
+        "slider",
+        "spinbutton",
+        "textbox",
+        "listbox",
+        "searchbox",
+        "combobox",
+        "checkbox",
+        "radio",
+        "switch",
+        "input[type=submit]",
+        "input[type=reset]",
+        "input[type=hidden]",
+        "input[type=image]",
+        "input[type=button]",
+        "button"
+    ];
+    FORMFIELD_LABEL_ATTRIBUTES = [
+        "aria-labelledby",
+        "aria-label",
+        "title",
+        "$LABEL"
+    ];
+    execute() {
+        // const foundElements = $(this.FORMFIELD_SELECTORS.join(","));
+        // const elements: HTMLElement[] = [];
+        // let counter = 0;
+        // while (counter < foundElements.length - 1) {
+        //     const element = foundElements[counter];
+        //     const attributeFound = rule.attributes.filter(value => {
+        //         return element.getAttribute(value);
+        //     });
+        //     if (attributeFound.length === 0) {
+        //         if (rule.attributes.includes(CustomAttribute.LABEL.toString())) {
+        //             if (!element.id) {
+        //                 elements.push(element);
+        //                 counter++;
+        //             } else {
+        //                 const foundLabelElements = jquery(`label[for=${element.id}]`);
+        //                 if (foundLabelElements.length === 0) {
+        //                     elements.push(element);
+        //                     counter++;
+        //                 }
+        //             }
+        //         }
+        //     }
+        //     counter++;
+        // }
+        //TODO implements filter
+        return [];
+    }
+    getSelector() {
+        return "FormFilter";
+    }
+}
+exports.FormQuery = FormQuery;

package/dist/lib/query/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./00-query";
+export * from "./by-tag.query";
+export * from "./doctype.query";
+export * from "./form.query";
+export * from "./by-role.query";
+export * from "./accessible-name.query";

package/dist/lib/query/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./00-query"), exports);
+__exportStar(require("./by-tag.query"), exports);
+__exportStar(require("./doctype.query"), exports);
+__exportStar(require("./form.query"), exports);
+__exportStar(require("./by-role.query"), exports);
+__exportStar(require("./accessible-name.query"), exports);

package/dist/lib/reference/alix/alix-checker.js

@@ -0,0 +1,82 @@
+"use strict";
+// import {
+//     AutoCheckRule,
+//     CheckRelevantSummary,
+//     ErrorSummary, LogTypeEnum,
+//     ManualCheckRule, Reference,
+//     RuleTypeEnum,
+//     ThirdPartyReferenceEnum,
+//     ThirdPartyTypeEnum
+// } from "../../model";
+// import { searchByRoleWithoutAttribute, searchByTag } from "../core";
+// import { alix } from "@uuv/runner-commons";
+// import { Observable } from "rxjs";
+//
+//
+// abstract class AlixChecker implements Reference {
+//   constructor(public version: string) {}
+//
+//   getErrorLogCommand(type: LogTypeEnum): string {
+//     throw new Error("Method not implemented.");
+//   }
+//   getCheckLogCommand(type: LogTypeEnum): string {
+//       throw new Error("Method not implemented.");
+//   }
+//
+//   type = ThirdPartyTypeEnum.UNKNOWN;
+//   errorSummary = new ErrorSummary(ThirdPartyReferenceEnum.ALIX);
+//   checkRelevantSummary = new CheckRelevantSummary(ThirdPartyReferenceEnum.ALIX);
+//   emitter: Observable<boolean> = new Observable();
+//
+//   checkCriteria(): void {
+//     cy.url({ log: false }).then(url => {
+//       this.errorSummary.url = url;
+//       this.checkRelevantSummary.url = url;
+//       alix.rules.sort((a: any, b: any) => {
+//         if (a.check > b.check) {
+//           return 1;
+//         }
+//         if (a.check < b.check) {
+//           return -1;
+//         }
+//         return 0;
+//       }).filter((elem) => {
+//         return elem.elementType.includes(this.type.toString());
+//       })
+//        .forEach((rule: any, index: number, array: any[]) => {
+//          const isLast = index + 1 === array.length;
+//          if (rule.type === RuleTypeEnum.ROLE) {
+//            searchByRoleWithoutAttribute(Object.assign(new ManualCheckRule, rule), this, isLast);
+//          }
+//          if (rule.type === RuleTypeEnum.TAG) {
+//            searchByTag(rule as AutoCheckRule, this, isLast);
+//          }
+//        });
+//     });
+//   }
+// }
+//
+// export class AlixError extends AlixChecker implements Reference {
+//   override type: ThirdPartyTypeEnum = ThirdPartyTypeEnum.ERROR;
+//   override getErrorLogCommand(type: LogTypeEnum): string {
+//     return `[${type.toString()}] error!`;
+//   }
+// }
+// export class AlixWarning extends AlixChecker implements Reference {
+//   override type: ThirdPartyTypeEnum = ThirdPartyTypeEnum.WARNING;
+//   override  getErrorLogCommand(type: LogTypeEnum): string {
+//       return `[${type.toString()}] warning!`;
+//   }
+// }
+// export class AlixAdvice extends AlixChecker implements Reference {
+//   override type: ThirdPartyTypeEnum = ThirdPartyTypeEnum.ADVICE;
+//   override getErrorLogCommand(type: LogTypeEnum): string {
+//     return `[${type.toString()}] advice!`;
+//   }
+// }
+// export class AlixObsolete extends AlixChecker implements Reference {
+//   override type: ThirdPartyTypeEnum = ThirdPartyTypeEnum.OBSOLETE;
+//   override getErrorLogCommand(type: LogTypeEnum): string {
+//     return `[${type.toString()}] obsolete!`;
+//   }
+// }