expect-webdriverio 5.6.9 → 6.0.0

package/lib/matchers/element/toHaveAttribute.js

@@ -1,63 +1,64 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function conditionAttr(el, attribute) {
-    const attr = await el.getAttribute(attribute);
-    if (typeof attr !== 'string') {
-        return { result: false, value: attr };
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { expect as wdioExpect } from '../../index.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+import { OneOfMatcher } from '../asymmetrics/oneOf.js';
+async function conditionAttributeValueMatchWithExpected(el, attribute, expectedValue, options) {
+    const attributeValue = await el.getAttribute(attribute);
+    if (typeof attributeValue !== 'string' || expectedValue === undefined || expectedValue === null) {
+        if (isAsymmetricMatcher(expectedValue)) {
+            return { success: expectedValue.asymmetricMatch(attributeValue), actual: attributeValue };
+        }
+        return { success: attributeValue === expectedValue, actual: attributeValue };
     }
-    return { result: true, value: attr };
-}
-async function conditionAttrAndValue(el, attribute, value, options) {
-    const attr = await el.getAttribute(attribute);
-    if (typeof attr !== 'string') {
-        return { result: false, value: attr };
+    else if (expectedValue instanceof OneOfMatcher) {
+        return { success: expectedValue.asymmetricMatch(attributeValue), actual: attributeValue };
     }
-    return compareText(attr, value, options);
-}
-export async function toHaveAttributeAndValue(received, attribute, value, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'attribute', verb = 'have' } = this;
-    let el = await received?.getElement();
-    let attr;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
-        el = result.el;
-        attr = result.values;
-        return result.success;
-    }, isNot, options);
-    const expected = wrapExpectedWithArray(el, attr, value);
-    const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
-    return {
-        pass,
-        message: () => message
-    };
+    return compareText(attributeValue, expectedValue, options);
 }
-async function toHaveAttributeFn(received, attribute) {
-    const isNot = this.isNot;
-    const { expectation = 'attribute', verb = 'have' } = this;
-    let el = await received?.getElement();
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
-        el = result.el;
-        return result.success;
-    }, isNot, {});
-    const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
+export async function toHaveAttributeAndValue(received, attribute, expectedValue, options = DEFAULT_OPTIONS) {
+    const { expectation = 'attribute', verb = 'have', isNot } = this;
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, values) => {
+                return conditionAttributeValueMatchWithExpected(element, attribute, values, options);
+            },
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expected = wrapExpectedWithArray(el, attr, expectedValue);
+    const message = enhanceError(el, expected, attr, { isNot, isSome }, verb, expectation, attribute, options);
     return {
         pass,
         message: () => message
     };
 }
 export async function toHaveAttribute(received, attribute, value, options = DEFAULT_OPTIONS) {
+    const matcherName = 'toHaveAttribute';
+    const paramsCount = arguments.length;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveAttribute',
+        matcherName,
         expectedValue: [attribute, value],
         options,
     });
-    const result = value !== undefined
-        ? await toHaveAttributeAndValue.call(this, received, attribute, value, options)
-        : await toHaveAttributeFn.call(this, received, attribute);
+    let expectedValue;
+    if (value === undefined) {
+        if (paramsCount > 2) {
+            console.warn('Using undefined or null as value for toHaveAttribute is deprecated and will be removed in v6.0.0. Please omit the third argument entirely or use toHaveAttribute(el, attribute, wdioExpect.anything(), options).');
+        }
+        expectedValue = wdioExpect.anything();
+    }
+    else {
+        expectedValue = value;
+    }
+    const result = await toHaveAttributeAndValue.call(this, received, attribute, expectedValue, options);
     await options.afterAssertion?.({
-        matcherName: 'toHaveAttribute',
+        matcherName,
         expectedValue: [attribute, value],
         options,
         result

package/lib/matchers/element/toHaveChildren.js

@@ -1,49 +1,47 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, options) {
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { isEmptyOrLegacyNumberOptions, validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+async function condition(el, expectedValue) {
     const children = await el.$$('./*').getElements();
-    if (typeof options.lte !== 'number' &&
-        typeof options.gte !== 'number' &&
-        typeof options.eq !== 'number') {
-        return {
-            result: children.length > 0,
-            value: children?.length
-        };
+    if (expectedValue === undefined) {
+        return { success: false, actual: children?.length };
     }
     return {
-        result: compareNumbers(children?.length, options),
-        value: children?.length
+        success: expectedValue?.asymmetricMatch(children?.length) ?? false,
+        actual: children?.length
     };
 }
-export async function toHaveChildren(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'children', verb = 'have' } = this;
+export async function toHaveChildren(received, expectedValueOrOptions, options = DEFAULT_OPTIONS) {
+    const { expectation = 'children', verb = 'have', isNot, matcherName = 'toHaveChildren' } = this;
+    const paramsCount = arguments.length;
+    if (paramsCount > 1 && (expectedValueOrOptions === undefined || isEmptyOrLegacyNumberOptions(expectedValueOrOptions))) {
+        console.warn('Passing undefined or NumberOptions as the second argument to toHaveChildren is deprecated. Use a NumberMatcher instead. For example, `expect(el).toHaveChildren({ gte: 1 }, options)`');
+    }
     await options.beforeAssertion?.({
-        matcherName: 'toHaveChildren',
-        expectedValue,
+        matcherName,
+        expectedValue: expectedValueOrOptions,
         options,
     });
-    const numberOptions = typeof expectedValue === 'number'
-        ? { eq: expectedValue }
-        : expectedValue || {};
-    let el = await received?.getElement();
-    let children;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, numberOptions, [numberOptions]);
-        el = result.el;
-        children = result.values;
-        return result.success;
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const expectedArray = wrapExpectedWithArray(el, children, error);
-    const message = enhanceError(el, expectedArray, children, this, verb, expectation, '', numberOptions);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValueOrOptions, options, { supportDefaultAsGteThen1: true });
+    const { success: pass, actual: children, subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedNumber,
+            singleElementCompare: (element, expectedValue) => condition(element, expectedValue),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+        });
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    const expectedArray = wrapExpectedWithArray(subject, children, expectedNumber);
+    const message = enhanceError(subject, expectedArray, children, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveChildren',
-        expectedValue,
+        matcherName,
+        expectedValue: expectedValueOrOptions,
         options,
         result
     });

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,35 +1,36 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, label, options) {
-    const actualLabel = await el.getComputedLabel();
-    if (Array.isArray(label)) {
-        return compareTextWithArray(actualLabel, label, options);
-    }
-    return compareText(actualLabel, label, options);
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(element, label, options) {
+    const actualLabel = await element.getComputedLabel();
+    return compareTextOrArray(actualLabel, label, options);
 }
 export async function toHaveComputedLabel(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'computed label', verb = 'have' } = this;
+    const { expectation = 'computed label', verb = 'have', isNot, matcherName = 'toHaveComputedLabel' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveComputedLabel',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualLabel;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualLabel = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, this, verb, expectation, '', options);
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveComputedLabel',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,35 +1,36 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, role, options) {
-    const actualRole = await el.getComputedRole();
-    if (Array.isArray(role)) {
-        return compareTextWithArray(actualRole, role, options);
-    }
-    return compareText(actualRole, role, options);
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(element, role, options) {
+    const actualRole = await element.getComputedRole();
+    return compareTextOrArray(actualRole, role, options);
 }
 export async function toHaveComputedRole(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'computed role', verb = 'have' } = this;
+    const { expectation = 'computed role', verb = 'have', isNot, matcherName = 'toHaveComputedRole' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveComputedRole',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualRole;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualRole = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, this, verb, expectation, '', options);
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: actualRole, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveComputedRole',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveElementClass.js

@@ -0,0 +1,57 @@
+import { DEFAULT_OPTIONS } from '../../constants.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareText, compareTextOrArray, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+async function singleElementCompare(el, attribute, value, options) {
+    const actualClass = await el.getAttribute(attribute);
+    if (value === undefined) {
+        return { success: false, actual: actualClass };
+    }
+    if (typeof actualClass !== 'string') {
+        return { success: false, actual: actualClass };
+    }
+    if (isAsymmetricMatcher(value)) {
+        return compareText(actualClass, value, options);
+    }
+    const classes = actualClass.split(' ');
+    const isValueInClasses = classes.some((clazz) => {
+        return compareTextOrArray(clazz, value, options).success;
+    });
+    return {
+        success: isValueInClasses,
+        actual: actualClass
+    };
+}
+export function toHaveClass(...args) {
+    return toHaveElementClass.call(this || {}, ...args);
+}
+export async function toHaveElementClass(received, expectedValue, options = DEFAULT_OPTIONS) {
+    const { expectation = 'class', verb = 'have', isNot, matcherName = 'toHaveElementClass' } = this;
+    await options.beforeAssertion?.({
+        matcherName,
+        expectedValue,
+        options,
+    });
+    const attribute = 'class';
+    const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, attribute, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, attr, expectedValue), attr, { isNot, isSome }, verb, expectation, '', options);
+    const result = {
+        pass,
+        message: () => message
+    };
+    await options.afterAssertion?.({
+        matcherName,
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,50 +1,58 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, property, value, options = DEFAULT_OPTIONS) {
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { expect as wdioExpect } from '../../index.js';
+import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+import { OneOfMatcher } from '../asymmetrics/oneOf.js';
+async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS) {
     const { asString = false } = options;
-    let prop = await el.getProperty(property);
-    if (prop === null || prop === undefined) {
-        return { result: false, value: prop };
+    const propertyValue = await el.getProperty(property);
+    if (propertyValue === null || propertyValue === undefined || (!(expectedValue instanceof RegExp) && typeof propertyValue !== 'string' && !asString)) {
+        if (isAsymmetricMatcher(expectedValue)) {
+            return { success: expectedValue.asymmetricMatch(propertyValue), actual: propertyValue };
+        }
+        return { success: propertyValue === expectedValue, actual: propertyValue };
     }
-    if (value === null) {
-        return { result: true, value: prop };
+    else if (expectedValue instanceof OneOfMatcher) {
+        return { success: expectedValue.asymmetricMatch(propertyValue), actual: propertyValue };
     }
-    if (!(value instanceof RegExp) && typeof prop !== 'string' && !asString) {
-        return { result: prop === value, value: prop };
-    }
-    prop = prop.toString();
-    return compareText(prop, value, options);
+    return compareText(propertyValue.toString(), expectedValue, options);
 }
 export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'property', verb = 'have' } = this;
+    const { expectation = 'property', verb = 'have', isNot, matcherName = 'toHaveElementProperty' } = this;
+    const paramsCount = arguments.length;
+    if (value === undefined || value === null) {
+        if (paramsCount > 2) {
+            console.warn('Using undefined or null as value for toHaveElementProperty is deprecated and will be removed in v6.0.0. Please omit the third argument entirely or use toHaveElementProperty(el, property, object.anything(), options).');
+        }
+        value = wdioExpect.anything();
+    }
     await options.beforeAssertion?.({
-        matcherName: 'toHaveElementProperty',
+        matcherName,
         expectedValue: [property, value],
         options,
     });
-    let el = await received?.getElement();
-    let prop;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [property, value]);
-        el = result.el;
-        prop = result.values;
-        return result.success;
-    }, isNot, options);
-    let message;
-    if (value === undefined) {
-        message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
-    }
-    else {
-        const expected = wrapExpectedWithArray(el, prop, value);
-        message = enhanceError(el, expected, prop, this, verb, expectation, property, options);
-    }
+    value = buildWdioAsymmetricMatchersWithOptions(value, options);
+    const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: value,
+            singleElementCompare: (element, expectedValue) => {
+                return condition(element, property, expectedValue, options);
+            },
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expected = wrapExpectedWithArray(elements, actualProppertyValue, value);
+    const message = enhanceError(elements, expected, actualProppertyValue, { isNot, isSome }, verb, expectation, property, options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveElementProperty',
+        matcherName,
         expectedValue: [property, value],
         options,
         result

package/lib/matchers/element/toHaveHTML.js

@@ -1,39 +1,38 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, html, options) {
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(el, html, options) {
     const actualHTML = await el.getHTML(options);
-    if (Array.isArray(html)) {
-        return compareTextWithArray(actualHTML, html, options);
-    }
-    return compareText(actualHTML, html, options);
+    return compareTextOrArray(actualHTML, html, options);
 }
 export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'HTML', verb = 'have' } = this;
+    const { expectation = 'HTML', verb = 'have', isNot, matcherName = 'toHaveHTML' } = this;
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
     await options.beforeAssertion?.({
-        matcherName: 'toHaveHTML',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = 'getElement' in received
-        ? await received?.getElement()
-        : 'getElements' in received
-            ? await received?.getElements()
-            : received;
-    let actualHTML;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualHTML = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, expectedValue), actualHTML, this, verb, expectation, '', options);
+    const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        const result = await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+        return result;
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expectedValues = wrapExpectedWithArray(elements, actualHTML, expectedValue);
+    const message = enhanceError(elements, expectedValues, actualHTML, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveHTML',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveHeight.js

@@ -1,46 +1,41 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
-async function condition(el, height, options) {
+import { wrapExpectedWithArray } from '../../util/elementsUtil.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { enhanceError, waitUntil, } from '../../utils.js';
+async function condition(el, expectedNumber) {
     const actualHeight = await el.getSize('height');
     return {
-        result: compareNumbers(actualHeight, options),
-        value: actualHeight
+        success: expectedNumber?.asymmetricMatch(actualHeight) ?? false,
+        actual: actualHeight
     };
 }
 export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'height', verb = 'have' } = this;
+    const { expectation = 'height', verb = 'have', isNot, matcherName = 'toHaveHeight' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveHeight',
+        matcherName,
         expectedValue,
         options,
     });
-    let numberOptions;
-    if (typeof expectedValue === 'number') {
-        numberOptions = { eq: expectedValue };
-    }
-    else if (!expectedValue || (typeof expectedValue.eq !== 'number' && typeof expectedValue.gte !== 'number' && typeof expectedValue.lte !== 'number')) {
-        throw new Error('Invalid params passed to toHaveHeight.');
-    }
-    else {
-        numberOptions = expectedValue;
-    }
-    let el = await received?.getElement();
-    let actualHeight;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
-        el = result.el;
-        actualHeight = result.values;
-        return result.success;
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError(el, error, actualHeight, this, verb, expectation, '', options);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
+    const { success: pass, actual: actualHeight, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedNumber,
+            singleElementCompare: (element, expectedNumber) => condition(element, expectedNumber),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    const expectedValues = wrapExpectedWithArray(elements, actualHeight, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualHeight, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveHeight',
+        matcherName,
         expectedValue,
         options,
         result