@uuv/a11y 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/lib/engine/engine.js

@@ -18,13 +18,14 @@ class Engine {
             observer.complete();
         });
     }
-    getRuleResult(rule, foundElements) {
+    getRuleResult(rule, queryResults) {
         if (rule.check === model_1.RuleCheckEnum.MANUAL) {
-            return this.buildResultForManualCheck(rule, foundElements);
+            return this.buildResultForManualCheck(rule, queryResults);
         }
         else {
             // Then we are considering rule as RuleCheckEnum.AUTO
-            return this.buildResultForAutoCheck(rule, foundElements);
+            const domNodes = queryResults.map((element) => element.domNode);
+            return this.buildResultForAutoCheck(rule, domNodes);
         }
     }
     buildResultForAutoCheck(rule, $el) {
@@ -62,30 +63,41 @@ class Engine {
         }
         return a11YRuleresult;
     }
-    buildResultForManualCheck(rule, $el) {
-        const a11YRuleresult = new model_1.A11yRuleResult(this.targetUrl, rule);
-        const validation = a11YRuleresult.getOrAddValidation(rule.criterion);
+    buildResultForManualCheck(rule, queryResults) {
+        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 < $el.length; i++) {
-            const selector = this.getSelector($el[i]);
+        for (const element of queryResults) {
+            const domNode = element.domNode;
+            const selector = this.getSelector(domNode);
             const attributesToCheck = [];
             rule.attributes.forEach((attribute) => {
-                const attributeFilledWithInformation = $el[i].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);
+            const manualValidation = a11YRuleResult.getOrAddValidation(rule.criterion);
             manualValidation.status = model_1.A11yResultStatus.MANUAL;
             manualValidation.nodesToCheckManually.push({
-                node: $el[i],
+                node: element,
                 selector: selector,
-                attributes: attributesToCheck.toString(),
-                html: $el[i].outerHTML,
+                attributes: attributesToCheck.join(", "),
+                html: domNode.outerHTML,
                 help: rule.id ? `${this.reference.getRuleUrl(rule.id)}` : ""
             });
         }
-        return a11YRuleresult;
+        return a11YRuleResult;
     }
     getSelector(element) {
         const path = [];

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

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

package/dist/lib/model/index.js

@@ -14,7 +14,7 @@ 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("./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.d.ts

@@ -1,5 +1,6 @@
 import { A11yRule } from "./rule";
 import { A11yReference } from "./reference";
+import { QueryResult } from "../query";
 export declare enum A11yResultStatus {
     UNKNOWN = "unknown",
     SUCCESS = "success",
@@ -12,7 +13,7 @@ export interface NonCompliantNode {
     html?: string;
 }
 export interface NodeToCheckManually {
-    node: HTMLElement;
+    node: QueryResult;
     selector: string;
     attributes: string;
     html: string;

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

@@ -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;
@@ -39,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/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

@@ -12,11 +12,11 @@ class AccessibleNameQuery {
     }
     execute() {
         return this.subQuery.execute().filter(element => {
-            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element);
-            if (this.shouldBeEmpty && (0, lodash_1.isEmpty)(accessibleName)) {
+            const accessibleName = (0, dom_accessibility_api_1.computeAccessibleName)(element.domNode);
+            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/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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ByTagQuery = void 0;
+const _00_query_1 = require("./00-query");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const $ = require("jquery/dist/jquery.min");
 class ByTagQuery {
@@ -9,7 +10,7 @@ class ByTagQuery {
         this.selectors = selectors;
     }
     execute() {
-        return $(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 (attributeValue === null || lodash_1.default.isEmpty(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 (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;