@uuv/a11y 1.0.0-beta.4 → 1.0.0-beta.40

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;

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;
 }

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoctypeQuery = void 0;
+const _00_query_1 = require("./00-query");
 class DoctypeQuery {
     execute() {
         if (document?.doctype?.name !== "html") {
-            return [document.documentElement];
+            return [new _00_query_1.QueryResult(document.documentElement)];
         }
         return [];
     }

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

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

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

@@ -3,4 +3,11 @@ export * from "./by-tag.query";
 export * from "./doctype.query";
 export * from "./form.query";
 export * from "./by-role.query";
+export * from "./by-sibling.query";
+export * from "./operators/operator-query";
+export * from "./operators/or-query";
+export * from "./operators/and-query";
 export * from "./accessible-name.query";
+export * from "./compliant-attributes/compliant-attributes.query";
+export * from "./compliant-attributes/attribute-checker";
+export * from "./compliant-attributes/attribut-specification";

package/dist/lib/query/index.js

@@ -19,4 +19,11 @@ __exportStar(require("./by-tag.query"), exports);
 __exportStar(require("./doctype.query"), exports);
 __exportStar(require("./form.query"), exports);
 __exportStar(require("./by-role.query"), exports);
+__exportStar(require("./by-sibling.query"), exports);
+__exportStar(require("./operators/operator-query"), exports);
+__exportStar(require("./operators/or-query"), exports);
+__exportStar(require("./operators/and-query"), exports);
 __exportStar(require("./accessible-name.query"), exports);
+__exportStar(require("./compliant-attributes/compliant-attributes.query"), exports);
+__exportStar(require("./compliant-attributes/attribute-checker"), exports);
+__exportStar(require("./compliant-attributes/attribut-specification"), exports);

package/dist/lib/query/operators/and-query.d.ts

@@ -0,0 +1,8 @@
+import { IOperatorQuery } from "./operator-query";
+import { Query, QueryResult } from "../00-query";
+export declare class AndQuery implements IOperatorQuery, Query {
+    readonly queries: Query[];
+    constructor(queries: Query[]);
+    execute(): QueryResult[];
+    getSelector(): string;
+}

package/dist/lib/query/operators/and-query.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndQuery = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const DOM_NODE_ATTRIBUTE = "domNode";
+class AndQuery {
+    queries;
+    constructor(queries) {
+        this.queries = queries;
+    }
+    execute() {
+        const queryResults = this.queries.map(query => query.execute());
+        return queryResults.reduce((left, right) => {
+            return lodash_1.default.intersectionBy(left, right, DOM_NODE_ATTRIBUTE);
+        });
+    }
+    getSelector() {
+        const result = this.queries.map(query => query.execute());
+        return `${lodash_1.default.intersection(...result).map(query => query.domNode).join(",")}`;
+    }
+}
+exports.AndQuery = AndQuery;

package/dist/lib/query/operators/operator-query.d.ts

@@ -0,0 +1,8 @@
+import { Query } from "../00-query";
+export interface IOperatorQuery {
+    queries: Query[];
+}
+export declare class OperatorQuery {
+    static Or: (...queries: Query[]) => Query;
+    static And: (...queries: Query[]) => Query;
+}

package/dist/lib/query/operators/operator-query.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorQuery = void 0;
+const or_query_1 = require("./or-query");
+const and_query_1 = require("./and-query");
+class OperatorQuery {
+    static Or = (...queries) => {
+        return new or_query_1.OrQuery(queries);
+    };
+    static And = (...queries) => {
+        return new and_query_1.AndQuery(queries);
+    };
+}
+exports.OperatorQuery = OperatorQuery;

package/dist/lib/query/operators/or-query.d.ts

@@ -0,0 +1,8 @@
+import { IOperatorQuery } from "./operator-query";
+import { Query, QueryResult } from "../00-query";
+export declare class OrQuery implements IOperatorQuery, Query {
+    readonly queries: Query[];
+    constructor(queries: Query[]);
+    execute(): QueryResult[];
+    getSelector(): string;
+}

package/dist/lib/query/operators/or-query.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrQuery = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const DOM_NODE_ATTRIBUTE = "domNode";
+class OrQuery {
+    queries;
+    constructor(queries) {
+        this.queries = queries;
+    }
+    execute() {
+        const queryResults = this.queries.map(query => query.execute());
+        return queryResults.reduce((left, right) => {
+            return lodash_1.default.unionBy(left, right, DOM_NODE_ATTRIBUTE);
+        });
+    }
+    getSelector() {
+        return `${this.queries.map(query => query.getSelector()).join(",")}`;
+    }
+}
+exports.OrQuery = OrQuery;