@uuv/a11y 1.0.0-beta.2 → 1.0.0-beta.21

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

@@ -1,7 +1,6 @@
 import { Query } from "../query/00-query";
 export interface A11yRule {
     attributes: string[];
-    reference: string;
     check: RuleCheckEnum;
     criterion: string;
     wcag: string;
@@ -14,7 +13,6 @@ export interface A11yRule {
 }
 export declare class AutoCheckA11yRule implements A11yRule {
     attributes: string[];
-    reference: string;
     check: RuleCheckEnum;
     criterion: string;
     wcag: string;
@@ -26,7 +24,6 @@ export declare class AutoCheckA11yRule implements A11yRule {
     shouldNotExist: boolean;
     static from(input: {
         attributes?: string[];
-        reference: string;
         criterion: string;
         wcag: string;
         id: string;
@@ -37,7 +34,6 @@ export declare class AutoCheckA11yRule implements A11yRule {
         shouldNotExist?: boolean;
     }): AutoCheckA11yRule & {
         attributes?: string[] | undefined;
-        reference: string;
         criterion: string;
         wcag: string;
         id: string;
@@ -50,7 +46,6 @@ export declare class AutoCheckA11yRule implements A11yRule {
 }
 export declare class ManualCheckA11yRule implements A11yRule {
     attributes: string[];
-    reference: string;
     check: RuleCheckEnum;
     criterion: string;
     wcag: string;
@@ -62,7 +57,6 @@ export declare class ManualCheckA11yRule implements A11yRule {
     shouldNotExist: boolean;
     static from(input: {
         attributes?: string[];
-        reference: string;
         criterion: string;
         wcag: string;
         id: string;
@@ -73,7 +67,6 @@ export declare class ManualCheckA11yRule implements A11yRule {
         shouldNotExist?: boolean;
     }): ManualCheckA11yRule & {
         attributes?: string[] | undefined;
-        reference: string;
         criterion: string;
         wcag: string;
         id: string;

package/dist/lib/model/rule.js

@@ -3,7 +3,6 @@ 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;
@@ -20,7 +19,6 @@ class AutoCheckA11yRule {
 exports.AutoCheckA11yRule = AutoCheckA11yRule;
 class ManualCheckA11yRule {
     attributes = [];
-    reference;
     check = RuleCheckEnum.MANUAL;
     criterion;
     wcag;

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

@@ -1,4 +1,9 @@
 export interface Query {
-    execute(): HTMLElement[];
+    execute(): QueryResult[];
     getSelector(): string;
 }
+export declare class QueryResult {
+    readonly domNode: HTMLElement;
+    readonly linkedNodes: HTMLElement[];
+    constructor(domNode: HTMLElement, linkedNodes?: HTMLElement[]);
+}

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

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryResult = void 0;
+class QueryResult {
+    domNode;
+    linkedNodes;
+    constructor(domNode, linkedNodes = []) {
+        this.domNode = domNode;
+        this.linkedNodes = linkedNodes;
+    }
+}
+exports.QueryResult = QueryResult;

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

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

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

@@ -1,11 +1,8 @@
 "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"));
+const lodash_1 = require("lodash");
 class AccessibleNameQuery {
     subQuery;
     shouldBeEmpty;
@@ -15,11 +12,11 @@ class AccessibleNameQuery {
     }
     execute() {
         return this.subQuery.execute().filter(element => {
-            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element);
-            if (this.shouldBeEmpty && lodash_1.default.isEmpty(accessibleName)) {
+            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element.domNode);
+            if (this.shouldBeEmpty && this.isNullOrEmpty(accessibleName)) {
                 return true;
             }
-            else if (!this.shouldBeEmpty && !lodash_1.default.isEmpty(accessibleName)) {
+            else if (!this.shouldBeEmpty && this.isNotNullAndNotEmpty(accessibleName)) {
                 return true;
             }
             else {
@@ -27,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/by-role.query.d.ts

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

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

@@ -1,27 +1,43 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ByRoleQuery = void 0;
+const _00_query_1 = require("./00-query");
 const dom_1 = require("@testing-library/dom");
+const lodash_1 = __importDefault(require("lodash"));
 class ByRoleQuery {
     role;
     attributes;
-    constructor(role, attributes = []) {
+    excludedTags;
+    constructor(role, attributes = [], excludedTags = []) {
         this.role = role;
         this.attributes = attributes;
+        this.excludedTags = excludedTags;
     }
     execute() {
         return (0, dom_1.queryAllByRole)(window.document.documentElement, this.role)
             ?.filter((element) => {
-            if (this.attributes.length == 0) {
+            if (lodash_1.default.isEmpty(this.attributes) && lodash_1.default.isEmpty(this.excludedTags)) {
                 return true;
             }
-            return this.attributes.filter(value => {
+            const foundExcludedTags = this.excludedTags.filter(value => {
+                return element.tagName.toLowerCase() === value;
+            });
+            const foundAttributes = this.attributes.filter(value => {
                 return element.getAttribute(value);
-            }).length > 0;
-        });
+            });
+            const hasFoundExcludedTags = !lodash_1.default.isEmpty(this.excludedTags) && !lodash_1.default.isEmpty(foundExcludedTags);
+            const hasFoundAttributes = !lodash_1.default.isEmpty(this.attributes) && !lodash_1.default.isEmpty(foundAttributes);
+            return (!hasFoundExcludedTags &&
+                hasFoundAttributes) ||
+                lodash_1.default.isEmpty(this.excludedTags) && hasFoundAttributes ||
+                lodash_1.default.isEmpty(this.attributes) && !hasFoundExcludedTags;
+        }).map((element) => new _00_query_1.QueryResult(element));
     }
     getSelector() {
-        return `ByRole(${this.role}, ${this.attributes})`;
+        return `ByRole(${this.role}, ${this.excludedTags}, ${this.attributes})`;
     }
 }
 exports.ByRoleQuery = ByRoleQuery;

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

@@ -0,0 +1,12 @@
+import { Query, QueryResult } from "./00-query";
+export declare class BySiblingQuery implements Query {
+    readonly subQuery: Query;
+    readonly shouldBeFound: boolean;
+    readonly siblingTags: string[];
+    constructor(subQuery: Query, shouldBeFound: boolean, siblingTags: string[]);
+    execute(): QueryResult[];
+    private computeResult;
+    private foundSiblingElement;
+    getSelector(): string;
+    private addGhostInputNode;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BySiblingQuery = void 0;
+const _00_query_1 = require("./00-query");
+const lodash_1 = __importDefault(require("lodash"));
+const emulate_tab_1 = require("emulate-tab");
+const DATA_TESTID = "data-testid";
+const BODY = "BODY";
+class BySiblingQuery {
+    subQuery;
+    shouldBeFound;
+    siblingTags;
+    constructor(subQuery, shouldBeFound, siblingTags) {
+        this.subQuery = subQuery;
+        this.shouldBeFound = shouldBeFound;
+        this.siblingTags = siblingTags;
+    }
+    execute() {
+        const result = [];
+        this.subQuery.execute().forEach((currentElement) => {
+            const element = currentElement.domNode;
+            element.focus();
+            if (document.activeElement?.tagName === BODY) {
+                const ghost = this.addGhostInputNode(element);
+                ghost.focus();
+                this.computeResult(element, result, ghost);
+                ghost.remove();
+            }
+            else {
+                this.computeResult(element, result);
+            }
+        });
+        return result;
+    }
+    computeResult(element, result, ghost = undefined) {
+        const elementFocused = ghost ?? element;
+        const siblingElements = [];
+        emulate_tab_1.emulateTab.findSelectableElements().forEach((value, index, collection) => {
+            if (value.getAttribute(DATA_TESTID) === elementFocused.getAttribute(DATA_TESTID)) {
+                const previousExist = index - 1 >= 0;
+                const nextExist = index + 1 <= collection.length - 1;
+                if (this.shouldBeFound) {
+                    if (previousExist && this.foundSiblingElement(collection[index - 1])) {
+                        siblingElements.push(collection[index - 1]);
+                    }
+                    if (nextExist && this.foundSiblingElement(collection[index + 1])) {
+                        siblingElements.push(collection[index + 1]);
+                    }
+                    if (!lodash_1.default.isEmpty(siblingElements)) {
+                        result.push(new _00_query_1.QueryResult(element, siblingElements));
+                    }
+                }
+                else {
+                    if ((previousExist &&
+                        !this.foundSiblingElement(collection[index - 1]) &&
+                        nextExist &&
+                        !this.foundSiblingElement(collection[index + 1]))) {
+                        siblingElements.push(collection[index - 1]);
+                        siblingElements.push(collection[index + 1]);
+                    }
+                    if ((previousExist &&
+                        !this.foundSiblingElement(collection[index - 1]) &&
+                        !nextExist)) {
+                        siblingElements.push(collection[index - 1]);
+                        result.push(new _00_query_1.QueryResult(element, siblingElements));
+                    }
+                    if ((!previousExist &&
+                        nextExist &&
+                        !this.foundSiblingElement(collection[index + 1]))) {
+                        siblingElements.push(collection[index + 1]);
+                    }
+                    if (!lodash_1.default.isEmpty(siblingElements)) {
+                        result.push(new _00_query_1.QueryResult(element, siblingElements));
+                    }
+                }
+            }
+        });
+    }
+    foundSiblingElement(element) {
+        return this.siblingTags.includes(element.tagName.toLowerCase());
+    }
+    getSelector() {
+        return `${this.subQuery.getSelector()}`;
+    }
+    addGhostInputNode(element) {
+        const input = document.createElement("input");
+        input.setAttribute(DATA_TESTID, "to-delete-" + String(Math.floor(Math.random() * Date.now())));
+        if (element.parentNode) {
+            element.parentNode.insertBefore(input, element.nextSibling);
+        }
+        else {
+            element.insertBefore(input, element.nextSibling);
+        }
+        return input;
+    }
+}
+exports.BySiblingQuery = BySiblingQuery;

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

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

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

@@ -1,17 +1,16 @@
 "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"));
+const _00_query_1 = require("./00-query");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const $ = require("jquery/dist/jquery.min");
 class ByTagQuery {
     selectors;
     constructor(selectors) {
         this.selectors = selectors;
     }
     execute() {
-        return (0, jquery_1.default)(this.selectors.join(",")).toArray();
+        return $(this.selectors.join(",")).toArray().map((element) => new _00_query_1.QueryResult(element));
     }
     getSelector() {
         return `${this.selectors}`;

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

@@ -0,0 +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 declare class EmptyElementWithIdSpecification implements IAttributeSpecification {
+    isSatisfiedBy(element: HTMLElement, attributeName: string): boolean;
+}
+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

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+        return lodash_1.default.isEmpty(attributeValue);
+    }
+}
+exports.EmptyAttributeSpecification = EmptyAttributeSpecification;
+class NotEmptyAttributeSpecification {
+    isSatisfiedBy(element, attributeName) {
+        const attributeValue = element.getAttribute(attributeName);
+        return !lodash_1.default.isEmpty(attributeValue);
+    }
+}
+exports.NotEmptyAttributeSpecification = NotEmptyAttributeSpecification;
+class EmptyElementWithIdSpecification {
+    isSatisfiedBy(element, attributeName) {
+        const attributeValue = element.getAttribute(attributeName);
+        if (lodash_1.default.isEmpty(attributeValue) || lodash_1.default.isNull(attributeValue)) {
+            return true;
+        }
+        const bindingNodeId = $(`#${attributeValue.replaceAll(".", "\\.")}`).text();
+        return lodash_1.default.isEmpty(bindingNodeId);
+    }
+}
+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 (lodash_1.default.isNull(attributeValue)) {
+            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 (lodash_1.default.isNull(attributeValue)) {
+            return false;
+        }
+        return this.expectedValueList.includes(attributeValue);
+    }
+}
+exports.EqualsAttributeSpecification = EqualsAttributeSpecification;
+class AccessibleNameNotContainsVisibleTextSpecification {
+    isSatisfiedBy(element, attributeName) {
+        const visibleText = element.textContent;
+        if (lodash_1.default.isNull(visibleText) || 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

@@ -0,0 +1,47 @@
+import { IAttributeSpecification } from "./attribut-specification";
+export declare class CompliantSpecification {
+    readonly attribute: string;
+    specification: IAttributeSpecification;
+    constructor(attribute: string, specification: IAttributeSpecification);
+}
+export declare class AttributeChecker {
+    /**
+     * Check if the value of the attributeName is empty
+     * @param attributeName : HTMLElement attributeName
+     */
+    static emptyAttribute(attributeName: string): CompliantSpecification;
+    /**
+     * Check if the value of the attributeName is not empty
+     * @param attributeName : HTMLElement attributeName
+     */
+    static notEmptyAttribute(attributeName: string): CompliantSpecification;
+    /**
+     * Check that the text of the HTMLElement whose id matches the value of the attribute named attributeName another HTMLElement is empty
+     * @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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeChecker = exports.CompliantSpecification = void 0;
+const attribut_specification_1 = require("./attribut-specification");
+class CompliantSpecification {
+    attribute;
+    specification;
+    constructor(attribute, specification) {
+        this.attribute = attribute;
+        this.specification = specification;
+    }
+}
+exports.CompliantSpecification = CompliantSpecification;
+class AttributeChecker {
+    /**
+     * Check if the value of the attributeName is empty
+     * @param attributeName : HTMLElement attributeName
+     */
+    static emptyAttribute(attributeName) {
+        return new CompliantSpecification(attributeName, new attribut_specification_1.EmptyAttributeSpecification());
+    }
+    /**
+     * Check if the value of the attributeName is not empty
+     * @param attributeName : HTMLElement attributeName
+     */
+    static notEmptyAttribute(attributeName) {
+        return new CompliantSpecification(attributeName, new attribut_specification_1.NotEmptyAttributeSpecification());
+    }
+    /**
+     * Check that the text of the HTMLElement whose id matches the value of the attribute named attributeName another HTMLElement is empty
+     * @param attributeName : HTMLElement attribute name
+     */
+    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/query/compliant-attributes/compliant-attributes.query.d.ts

@@ -0,0 +1,9 @@
+import { Query, QueryResult } from "../00-query";
+import { CompliantSpecification } from "./attribute-checker";
+export declare class CompliantAttributesQuery implements Query {
+    readonly subQuery: Query;
+    readonly attributeSpecifications: CompliantSpecification[];
+    constructor(subQuery: Query, attributeSpecifications: CompliantSpecification[]);
+    execute(): QueryResult[];
+    getSelector(): string;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompliantAttributesQuery = void 0;
+class CompliantAttributesQuery {
+    subQuery;
+    attributeSpecifications;
+    constructor(subQuery, attributeSpecifications) {
+        this.subQuery = subQuery;
+        this.attributeSpecifications = attributeSpecifications;
+    }
+    execute() {
+        return this.subQuery.execute().filter((element) => {
+            let result = true;
+            this.attributeSpecifications.forEach(attributeSpecification => {
+                result = result && attributeSpecification.specification.isSatisfiedBy(element.domNode, attributeSpecification.attribute);
+            });
+            return result;
+        });
+    }
+    getSelector() {
+        return `CompliantAttributes: ${this.subQuery.getSelector()}`;
+    }
+}
+exports.CompliantAttributesQuery = CompliantAttributesQuery;

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

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