@uuv/a11y 1.0.0-beta.7 → 1.0.0-beta.70

package/dist/README.md

@@ -1,9 +1,9 @@
 
 # @uuv/a11y
 <div align="center">  
-<a href="https://orange-opensource.github.io/uuv/">  
+<a href="https://e2e-test-quest.github.io/uuv/">  
 <picture>  
-<img alt="UUV Logo" src="https://orange-opensource.github.io/uuv/img/uuv.png">  
+<img alt="UUV Logo" src="https://e2e-test-quest.github.io/uuv/img/uuv.png">  
 </picture>  
 </a>  
 </div>  
@@ -70,7 +70,7 @@ For each criterion of the RGAA, the following algorithm is executed :
 
  ![Diagram a11Y RGAA](https://unpkg.com/@uuv/a11y/docs/diagram-a11y-rgaa.png)
 
-**Consult [this page](https://orange-opensource.github.io/uuv/docs/tools/uuv-a11y#rgaa) to find out which RGAA verifications are implemented in the library**
+**Consult [this page](https://e2e-test-quest.github.io/uuv/docs/tools/uuv-a11y#rgaa) to find out which RGAA verifications are implemented in the library**
 </p>  
 
 ## Usage
@@ -156,22 +156,22 @@ For each criterion of the RGAA, the following algorithm is executed :
                }
                """
           ```
-   You can also see the [French example](https://github.com/Orange-OpenSource/uuv/blob/main/example/fr-rgaa.feature) or the complete [English example](https://github.com/Orange-OpenSource/uuv/blob/main/example/en-rgaa.feature).
+   You can also see the [French example](https://github.com/e2e-test-quest/uuv/blob/main/example/fr-rgaa.feature) or the complete [English example](https://github.com/e2e-test-quest/uuv/blob/main/example/en-rgaa.feature).
 3. Then execute your tests :
     ```shell
     npx uuv e2e
     ```
 
 ## Want to contribute ?
-Your help is welcome, see the [Contributors guide](https://github.com/Orange-OpenSource/uuv/blob/main/packages/a11y/CONTRIBUTING.md).
+Your help is welcome, see the [Contributors guide](https://github.com/e2e-test-quest/uuv/blob/main/packages/a11y/CONTRIBUTING.md).
 
 ## License
 
-[<a href="https://github.com/Orange-OpenSource/uuv/blob/main/LICENSE">  
+[<a href="https://github.com/e2e-test-quest/uuv/blob/main/LICENSE">  
 <img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"/>  
 </a>](https://spdx.org/licenses/MIT.html)
 
-This project is licensed under the terms of the [MIT license](https://github.com/Orange-OpenSource/uuv/blob/main/LICENSE).
+This project is licensed under the terms of the [MIT license](https://github.com/e2e-test-quest/uuv/blob/main/LICENSE).
 
 ## Authors
 

package/dist/lib/engine/engine.js

@@ -67,22 +67,32 @@ class Engine {
         const a11YRuleResult = new model_1.A11yRuleResult(this.targetUrl, rule);
         const validation = a11YRuleResult.getOrAddValidation(rule.criterion);
         validation.status = model_1.A11yResultStatus.SUCCESS;
-        for (let i = 0; i < queryResults.length; i++) {
-            const domNode = queryResults[i].domNode;
+        for (const element of queryResults) {
+            const domNode = element.domNode;
             const selector = this.getSelector(domNode);
             const attributesToCheck = [];
             rule.attributes.forEach((attribute) => {
-                const attributeFilledWithInformation = domNode.getAttribute(attribute);
-                if (attributeFilledWithInformation) {
-                    attributesToCheck.push(` ${attribute}=${attributeFilledWithInformation}`);
+                const childData = attribute.split(":");
+                if (childData.length > 1) {
+                    domNode.childNodes.forEach((childNode) => {
+                        if (childNode.nodeName === childData[1]) {
+                            attributesToCheck.push(`${attribute}=${childNode.textContent}`);
+                        }
+                    });
+                }
+                else {
+                    const attributeFilledWithInformation = domNode.getAttribute(attribute);
+                    if (attributeFilledWithInformation) {
+                        attributesToCheck.push(`${attribute}=${attributeFilledWithInformation}`);
+                    }
                 }
             });
             const manualValidation = a11YRuleResult.getOrAddValidation(rule.criterion);
             manualValidation.status = model_1.A11yResultStatus.MANUAL;
             manualValidation.nodesToCheckManually.push({
-                node: queryResults[i],
+                node: element,
                 selector: selector,
-                attributes: attributesToCheck.toString(),
+                attributes: attributesToCheck.join(", "),
                 html: domNode.outerHTML,
                 help: rule.id ? `${this.reference.getRuleUrl(rule.id)}` : ""
             });

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

@@ -1,14 +1,5 @@
-import { A11yReference } from "./reference";
 import { Observable } from "rxjs";
-import { A11yResult } from "./result";
-import { A11yRule } from "./rule";
-import { Engine } from "../engine/engine";
-export declare abstract class A11yChecker {
-    readonly url: string;
-    readonly engine: Engine;
-    readonly reference: A11yReference;
-    protected constructor(url: string, engine: Engine, reference: A11yReference);
-    abstract rules(): A11yRule[];
-    validate(): Observable<A11yResult>;
-    private buildCheckList;
+import { UuvA11yResultUsecase, UuvA11yResultUsecaseLocation } from "./uuv-a11y-result";
+export interface A11yChecker {
+    validate(name: string, script: string, location: UuvA11yResultUsecaseLocation): Observable<UuvA11yResultUsecase>;
 }

package/dist/lib/model/checker.js

@@ -1,35 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.A11yChecker = void 0;
-const rxjs_1 = require("rxjs");
-const result_1 = require("./result");
-class A11yChecker {
-    url;
-    engine;
-    reference;
-    constructor(url, engine, reference) {
-        this.url = url;
-        this.engine = engine;
-        this.reference = reference;
-    }
-    validate() {
-        const result = new result_1.A11yResult(this.url, this.reference);
-        const rules = this.rules();
-        const checkList = this.buildCheckList(rules);
-        return (0, rxjs_1.forkJoin)(checkList)
-            .pipe((0, rxjs_1.map)((ruleResults) => {
-            result.ruleResults = ruleResults;
-            result.computeStatus();
-            return result;
-        }), (0, rxjs_1.tap)(result => {
-            console.debug("result");
-            console.debug(result);
-        }));
-    }
-    buildCheckList(rules) {
-        const checkList = [];
-        rules.forEach(rule => checkList.push(this.engine.buildCheckListItemFromRule(rule)));
-        return checkList;
-    }
-}
-exports.A11yChecker = A11yChecker;

package/dist/lib/model/checklist-checker.d.ts

@@ -0,0 +1,15 @@
+import { A11yReference } from "./reference";
+import { Observable } from "rxjs";
+import { A11yRule } from "./rule";
+import { Engine } from "../engine/engine";
+import { A11yChecker } from "./checker";
+import { UuvA11yResultUsecase, UuvA11yResultUsecaseLocation } from "./uuv-a11y-result";
+export declare abstract class A11yChecklistChecker implements A11yChecker {
+    readonly url: string;
+    readonly engine: Engine;
+    readonly reference: A11yReference;
+    protected constructor(url: string, engine: Engine, reference: A11yReference);
+    abstract rules(): A11yRule[];
+    validate(name: string, script: string, location: UuvA11yResultUsecaseLocation): Observable<UuvA11yResultUsecase>;
+    private buildCheckList;
+}

package/dist/lib/model/checklist-checker.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A11yChecklistChecker = void 0;
+const reference_1 = require("./reference");
+const rxjs_1 = require("rxjs");
+const result_1 = require("./result");
+const uuv_a11y_result_1 = require("./uuv-a11y-result");
+class A11yChecklistChecker {
+    url;
+    engine;
+    reference;
+    constructor(url, engine, reference) {
+        this.url = url;
+        this.engine = engine;
+        this.reference = reference;
+    }
+    validate(name, script, location) {
+        const result = new result_1.A11yResult(this.url, this.reference);
+        const rules = this.rules();
+        const checkList = this.buildCheckList(rules);
+        return (0, rxjs_1.forkJoin)(checkList)
+            .pipe((0, rxjs_1.map)((ruleResults) => {
+            result.ruleResults = ruleResults;
+            result.computeStatus();
+            const issues = ruleResults.map(ruleResult => {
+                return {
+                    type: uuv_a11y_result_1.IssueType.Error,
+                    code: ruleResult.rule.id,
+                    message: ruleResult.rule.description || "",
+                    selector: ruleResult.getErrorNodes().map(error => error.selector).join(", "),
+                    runnerExtras: {
+                        rule: ruleResult.rule,
+                        validations: ruleResult.validations,
+                        errorNodes: ruleResult.getErrorNodes()
+                    }
+                };
+            });
+            return {
+                name,
+                script,
+                location,
+                result: {
+                    date: (new Date()).getTime(),
+                    reference: reference_1.A11yReferenceEnum.WCAG_WEB,
+                    issues,
+                    rawResult: result,
+                    status: result.status
+                },
+            };
+        }), (0, rxjs_1.tap)(result => {
+            console.debug("result");
+            console.debug(result);
+        }));
+    }
+    buildCheckList(rules) {
+        const checkList = [];
+        rules.forEach(rule => checkList.push(this.engine.buildCheckListItemFromRule(rule)));
+        return checkList;
+    }
+}
+exports.A11yChecklistChecker = A11yChecklistChecker;

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

@@ -1,4 +1,5 @@
-export * from "./checker";
 export * from "./reference";
+export * from "./checker";
 export * from "./result";
+export * from "./uuv-a11y-result";
 export * from "./rule";

package/dist/lib/model/index.js

@@ -14,7 +14,8 @@ 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("./checker"), exports);
 __exportStar(require("./reference"), exports);
+__exportStar(require("./checker"), exports);
 __exportStar(require("./result"), exports);
+__exportStar(require("./uuv-a11y-result"), exports);
 __exportStar(require("./rule"), exports);

package/dist/lib/model/reference.js

@@ -7,7 +7,7 @@ var A11yReferenceEnum;
     A11yReferenceEnum["WCAG_WEB"] = "WCAG-WEB";
     A11yReferenceEnum["WCAG_ANDROID"] = "WCAG-ANDROID";
     A11yReferenceEnum["WCAG_IOS"] = "WCAG-IOS";
-})(A11yReferenceEnum = exports.A11yReferenceEnum || (exports.A11yReferenceEnum = {}));
+})(A11yReferenceEnum || (exports.A11yReferenceEnum = A11yReferenceEnum = {}));
 class Comments {
     info;
     warning;

package/dist/lib/model/result.js

@@ -7,7 +7,7 @@ var A11yResultStatus;
     A11yResultStatus["SUCCESS"] = "success";
     A11yResultStatus["MANUAL"] = "manual";
     A11yResultStatus["ERROR"] = "error";
-})(A11yResultStatus = exports.A11yResultStatus || (exports.A11yResultStatus = {}));
+})(A11yResultStatus || (exports.A11yResultStatus = A11yResultStatus = {}));
 class A11yRuleValidationResult {
     criteria;
     status = A11yResultStatus.UNKNOWN;

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

@@ -33,15 +33,15 @@ export declare class AutoCheckA11yRule implements A11yRule {
         help?: string | string[];
         shouldNotExist?: boolean;
     }): AutoCheckA11yRule & {
-        attributes?: string[] | undefined;
+        attributes?: string[];
         criterion: string;
         wcag: string;
         id: string;
         elementType: string;
         query: Query;
-        description?: string | undefined;
-        help?: string | string[] | undefined;
-        shouldNotExist?: boolean | undefined;
+        description?: string;
+        help?: string | string[];
+        shouldNotExist?: boolean;
     };
 }
 export declare class ManualCheckA11yRule implements A11yRule {
@@ -66,15 +66,15 @@ export declare class ManualCheckA11yRule implements A11yRule {
         help?: string;
         shouldNotExist?: boolean;
     }): ManualCheckA11yRule & {
-        attributes?: string[] | undefined;
+        attributes?: string[];
         criterion: string;
         wcag: string;
         id: string;
         elementType: string;
         query: Query;
-        description?: string | undefined;
-        help?: string | undefined;
-        shouldNotExist?: boolean | undefined;
+        description?: string;
+        help?: string;
+        shouldNotExist?: boolean;
     };
 }
 export declare enum RuleCheckEnum {

package/dist/lib/model/rule.js

@@ -37,15 +37,15 @@ var RuleCheckEnum;
 (function (RuleCheckEnum) {
     RuleCheckEnum["MANUAL"] = "MANUAL";
     RuleCheckEnum["AUTO"] = "AUTO";
-})(RuleCheckEnum = exports.RuleCheckEnum || (exports.RuleCheckEnum = {}));
+})(RuleCheckEnum || (exports.RuleCheckEnum = RuleCheckEnum = {}));
 var CustomFilter;
 (function (CustomFilter) {
     CustomFilter["DOCTYPE"] = "$DOCTYPE";
     CustomFilter["FORM_FIELD"] = "$FORMFIELD";
-})(CustomFilter = exports.CustomFilter || (exports.CustomFilter = {}));
+})(CustomFilter || (exports.CustomFilter = CustomFilter = {}));
 var RuleTypeEnum;
 (function (RuleTypeEnum) {
     RuleTypeEnum["TAG"] = "TAG";
     RuleTypeEnum["ROLE"] = "ROLE";
     RuleTypeEnum["COLOR"] = "COLOR";
-})(RuleTypeEnum = exports.RuleTypeEnum || (exports.RuleTypeEnum = {}));
+})(RuleTypeEnum || (exports.RuleTypeEnum = RuleTypeEnum = {}));

package/dist/lib/model/uuv-a11y-result.d.ts

@@ -0,0 +1,54 @@
+import { A11yReferenceEnum } from "./reference";
+import { A11yResultStatus } from "./result";
+export declare enum IssueType {
+    Warning = "warning",
+    Error = "error",
+    Notice = "notice"
+}
+export type UuvA11yResultApp = {
+    name: string;
+    description: string;
+    usecases: UuvA11yResultUsecase[];
+};
+export type UuvA11yResultUsecase = {
+    name: string;
+    script: string;
+    location: UuvA11yResultUsecaseLocation;
+    result: UuvA11yResultExecution;
+};
+export type UuvA11yResultUsecaseLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
+export type UuvA11yResultExecution = {
+    date: number;
+    reference: A11yReferenceEnum;
+    issues: AccessibilityIssue[];
+    status: A11yResultStatus;
+    rawResult?: any;
+};
+export type AccessibilityIssue = {
+    type: IssueType;
+    code: string;
+    message: string;
+    selector: string;
+    htmlElement?: Element | null;
+    runnerExtras: RunnerExtras | any;
+};
+export type RunnerExtras = {
+    description: string;
+    impact: IssueImpact;
+    help: string;
+    helpUrl: string;
+};
+export declare enum IssueImpact {
+    Minor = "minor",
+    Moderate = "moderate",
+    Serious = "serious",
+    Critical = "critical",
+    Unknown = "unknown"
+}
+export type UuvA11yResult = {
+    app: UuvA11yResultApp;
+};

package/dist/lib/model/uuv-a11y-result.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueImpact = exports.IssueType = void 0;
+var IssueType;
+(function (IssueType) {
+    IssueType["Warning"] = "warning";
+    IssueType["Error"] = "error";
+    IssueType["Notice"] = "notice";
+})(IssueType || (exports.IssueType = IssueType = {}));
+var IssueImpact;
+(function (IssueImpact) {
+    IssueImpact["Minor"] = "minor";
+    IssueImpact["Moderate"] = "moderate";
+    IssueImpact["Serious"] = "serious";
+    IssueImpact["Critical"] = "critical";
+    IssueImpact["Unknown"] = "unknown";
+})(IssueImpact || (exports.IssueImpact = IssueImpact = {}));

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

@@ -4,5 +4,7 @@ export declare class AccessibleNameQuery implements Query {
     readonly shouldBeEmpty: boolean;
     constructor(subQuery: Query, shouldBeEmpty: boolean);
     execute(): QueryResult[];
+    private isNullOrEmpty;
+    private isNotNullAndNotEmpty;
     getSelector(): string;
 }

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

@@ -13,10 +13,10 @@ class AccessibleNameQuery {
     execute() {
         return this.subQuery.execute().filter(element => {
             const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element.domNode);
-            if (this.shouldBeEmpty && (0, lodash_1.isEmpty)(accessibleName)) {
+            if (this.shouldBeEmpty && this.isNullOrEmpty(accessibleName)) {
                 return true;
             }
-            else if (!this.shouldBeEmpty && !(0, lodash_1.isEmpty)(accessibleName)) {
+            else if (!this.shouldBeEmpty && this.isNotNullAndNotEmpty(accessibleName)) {
                 return true;
             }
             else {
@@ -24,6 +24,12 @@ class AccessibleNameQuery {
             }
         });
     }
+    isNullOrEmpty(accessibleName) {
+        return (0, lodash_1.isNull)(accessibleName) || (0, lodash_1.isEmpty)(accessibleName);
+    }
+    isNotNullAndNotEmpty(accessibleName) {
+        return !(0, lodash_1.isNull)(accessibleName) && !(0, lodash_1.isEmpty)(accessibleName);
+    }
     getSelector() {
         return `AccessibleName: ${this.subQuery.getSelector()}`;
     }

package/dist/lib/query/compliant-attributes/attribut-specification.d.ts

@@ -1,12 +1,34 @@
+export interface IAttributeSpecification {
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
 export declare class EmptyAttributeSpecification implements IAttributeSpecification {
     isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
 }
 export declare class NotEmptyAttributeSpecification implements IAttributeSpecification {
     isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
 }
-export interface IAttributeSpecification {
+export declare class EmptyElementWithIdSpecification implements IAttributeSpecification {
     isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
 }
-export declare class EmptyElementWithIdSpecification implements IAttributeSpecification {
+export declare class NotUniqueIdAttributeSpecification implements IAttributeSpecification {
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+export declare class NotEqualsAttributeSpecification implements IAttributeSpecification {
+    private expectedValueList;
+    constructor(expectedValueList: string[]);
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+export declare class EqualsAttributeSpecification implements IAttributeSpecification {
+    private expectedValueList;
+    constructor(expectedValueList: string[]);
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+export declare class AccessibleNameNotContainsVisibleTextSpecification implements IAttributeSpecification {
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+export declare class EmptyInnerTextSpecification implements IAttributeSpecification {
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+export declare class NotEmptyInnerTextSpecification implements IAttributeSpecification {
     isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
 }

package/dist/lib/query/compliant-attributes/attribut-specification.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyElementWithIdSpecification = exports.NotEmptyAttributeSpecification = exports.EmptyAttributeSpecification = void 0;
+exports.NotEmptyInnerTextSpecification = exports.EmptyInnerTextSpecification = exports.AccessibleNameNotContainsVisibleTextSpecification = exports.EqualsAttributeSpecification = exports.NotEqualsAttributeSpecification = exports.NotUniqueIdAttributeSpecification = exports.EmptyElementWithIdSpecification = exports.NotEmptyAttributeSpecification = exports.EmptyAttributeSpecification = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const $ = require("jquery/dist/jquery.min");
+const dom_accessibility_api_1 = require("dom-accessibility-api");
 class EmptyAttributeSpecification {
     isSatisfiedBy(element, attributeName) {
         const attributeValue = element.getAttribute(attributeName);
@@ -24,7 +25,7 @@ exports.NotEmptyAttributeSpecification = NotEmptyAttributeSpecification;
 class EmptyElementWithIdSpecification {
     isSatisfiedBy(element, attributeName) {
         const attributeValue = element.getAttribute(attributeName);
-        if (lodash_1.default.isEmpty(attributeValue) || lodash_1.default.isNull(attributeValue)) {
+        if (attributeValue === null || lodash_1.default.isEmpty(attributeValue)) {
             return true;
         }
         const bindingNodeId = $(`#${attributeValue.replaceAll(".", "\\.")}`).text();
@@ -32,3 +33,64 @@ class EmptyElementWithIdSpecification {
     }
 }
 exports.EmptyElementWithIdSpecification = EmptyElementWithIdSpecification;
+class NotUniqueIdAttributeSpecification {
+    isSatisfiedBy(element, attributeName) {
+        if (lodash_1.default.isNull(element.id) || lodash_1.default.isEmpty(element.id)) {
+            return true;
+        }
+        return $(`[id=${element.id}]`).length > 1;
+    }
+}
+exports.NotUniqueIdAttributeSpecification = NotUniqueIdAttributeSpecification;
+class NotEqualsAttributeSpecification {
+    expectedValueList;
+    constructor(expectedValueList) {
+        this.expectedValueList = expectedValueList;
+    }
+    isSatisfiedBy(element, attributeName) {
+        const attributeValue = element.getAttribute(attributeName);
+        if (attributeValue === null) {
+            return true;
+        }
+        return !this.expectedValueList.includes(attributeValue);
+    }
+}
+exports.NotEqualsAttributeSpecification = NotEqualsAttributeSpecification;
+class EqualsAttributeSpecification {
+    expectedValueList;
+    constructor(expectedValueList) {
+        this.expectedValueList = expectedValueList;
+    }
+    isSatisfiedBy(element, attributeName) {
+        const attributeValue = element.getAttribute(attributeName);
+        if (attributeValue === null) {
+            return false;
+        }
+        return this.expectedValueList.includes(attributeValue);
+    }
+}
+exports.EqualsAttributeSpecification = EqualsAttributeSpecification;
+class AccessibleNameNotContainsVisibleTextSpecification {
+    isSatisfiedBy(element, attributeName) {
+        const visibleText = element.textContent;
+        if (visibleText === null || lodash_1.default.isEmpty(visibleText)) {
+            return false;
+        }
+        const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element);
+        console.debug("visibleText", visibleText, "accessibleName", accessibleName);
+        return accessibleName?.toLowerCase().indexOf(visibleText.toLowerCase()) === -1;
+    }
+}
+exports.AccessibleNameNotContainsVisibleTextSpecification = AccessibleNameNotContainsVisibleTextSpecification;
+class EmptyInnerTextSpecification {
+    isSatisfiedBy(element, attributeName) {
+        return lodash_1.default.isEmpty(element.textContent);
+    }
+}
+exports.EmptyInnerTextSpecification = EmptyInnerTextSpecification;
+class NotEmptyInnerTextSpecification {
+    isSatisfiedBy(element, attributeName) {
+        return !lodash_1.default.isEmpty(element.textContent);
+    }
+}
+exports.NotEmptyInnerTextSpecification = NotEmptyInnerTextSpecification;

package/dist/lib/query/compliant-attributes/attribute-checker.d.ts

@@ -20,4 +20,28 @@ export declare class AttributeChecker {
      * @param attributeName : HTMLElement attribute name
      */
     static emptyHtmlNodeTargetedByTheAttribute(attributeName: string): CompliantSpecification;
+    /**
+     * Check that id attribute is not unique in current page
+     */
+    static notUniqueId(): CompliantSpecification;
+    /**
+     * Check that html element does not have the expected value
+     */
+    static notEquals(attributeName: string, expectedValueList: string[]): CompliantSpecification;
+    /**
+     * Check that html element have the expected value
+     */
+    static equals(attributeName: string, expectedValueList: string[]): CompliantSpecification;
+    /**
+     * Check that html element accessible name contains visible text ignoring case
+     */
+    static accessibleNameNotContainsVisibleText(): CompliantSpecification;
+    /**
+     * Check that html element have empty text
+     */
+    static emptyText(): CompliantSpecification;
+    /**
+     * Check that html element have not empty text
+     */
+    static notEmptyText(): CompliantSpecification;
 }

package/dist/lib/query/compliant-attributes/attribute-checker.js

@@ -33,5 +33,41 @@ class AttributeChecker {
     static emptyHtmlNodeTargetedByTheAttribute(attributeName) {
         return new CompliantSpecification(attributeName, new attribut_specification_1.EmptyElementWithIdSpecification());
     }
+    /**
+     * Check that id attribute is not unique in current page
+     */
+    static notUniqueId() {
+        return new CompliantSpecification("id", new attribut_specification_1.NotUniqueIdAttributeSpecification());
+    }
+    /**
+     * Check that html element does not have the expected value
+     */
+    static notEquals(attributeName, expectedValueList) {
+        return new CompliantSpecification(attributeName, new attribut_specification_1.NotEqualsAttributeSpecification(expectedValueList));
+    }
+    /**
+     * Check that html element have the expected value
+     */
+    static equals(attributeName, expectedValueList) {
+        return new CompliantSpecification(attributeName, new attribut_specification_1.EqualsAttributeSpecification(expectedValueList));
+    }
+    /**
+     * Check that html element accessible name contains visible text ignoring case
+     */
+    static accessibleNameNotContainsVisibleText() {
+        return new CompliantSpecification("accessibleName", new attribut_specification_1.AccessibleNameNotContainsVisibleTextSpecification());
+    }
+    /**
+     * Check that html element have empty text
+     */
+    static emptyText() {
+        return new CompliantSpecification("text", new attribut_specification_1.EmptyInnerTextSpecification());
+    }
+    /**
+     * Check that html element have not empty text
+     */
+    static notEmptyText() {
+        return new CompliantSpecification("text", new attribut_specification_1.NotEmptyInnerTextSpecification());
+    }
 }
 exports.AttributeChecker = AttributeChecker;

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

@@ -1 +1,2 @@
 export * from "./rgaa";
+export * from "./wcag";

package/dist/lib/reference/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // export * from './alix';
 __exportStar(require("./rgaa"), exports);
+__exportStar(require("./wcag"), exports);