expect-webdriverio 6.1.0 → 8.0.0-alpha.0

package/lib/matchers/element/toHaveAttribute.js

@@ -20,7 +20,7 @@ async function conditionAttributeValueMatchWithExpected(el, attribute, expectedV
 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) => {
+    const { success: pass, actual: attr, subject: el, context: { isSome } = {}, expected: expectedValues } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
@@ -29,10 +29,9 @@ export async function toHaveAttributeAndValue(received, attribute, expectedValue
                 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 expected = expectedValues ?? wrapExpectedWithArray(el, attr, expectedValue);
     const message = enhanceError(el, expected, attr, { isNot, isSome }, verb, expectation, attribute, options);
     return {
         pass,
@@ -40,23 +39,13 @@ export async function toHaveAttributeAndValue(received, attribute, expectedValue
     };
 }
 export async function toHaveAttribute(received, attribute, value, options = DEFAULT_OPTIONS) {
-    const matcherName = 'toHaveAttribute';
-    const paramsCount = arguments.length;
+    const { matcherName = 'toHaveAttribute' } = this;
     await options.beforeAssertion?.({
         matcherName,
         expectedValue: [attribute, value],
         options,
     });
-    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 = expect.anything();
-    }
-    else {
-        expectedValue = value;
-    }
+    const expectedValue = value ?? expect.anything();
     const result = await toHaveAttributeAndValue.call(this, received, attribute, expectedValue, options);
     await options.afterAssertion?.({
         matcherName,
@@ -66,4 +55,3 @@ export async function toHaveAttribute(received, attribute, value, options = DEFA
     });
     return result;
 }
-export const toHaveAttr = toHaveAttribute;

package/lib/matchers/element/toHaveChildren.js

@@ -1,6 +1,6 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { isEmptyOrLegacyNumberOptions, validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { validateNumberMatcherArray } from '../../util/numberOptionsUtil.js';
 import { enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, expectedValue) {
     const children = await el.$$('./*').getElements();
@@ -12,36 +12,31 @@ async function condition(el, expectedValue) {
         actual: children?.length
     };
 }
-export async function toHaveChildren(received, expectedValueOrOptions, options = DEFAULT_OPTIONS) {
+export async function toHaveChildren(received, expectedValue, 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,
-        expectedValue: expectedValueOrOptions,
+        expectedValue,
         options,
     });
-    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValueOrOptions, options, { supportDefaultAsGteThen1: true });
-    const { success: pass, actual: children, subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const expectedNumber = validateNumberMatcherArray(expectedValue, { supportDefaultAsGteThen1: true });
+    const { success: pass, actual: children, subject, context: { isSome } = {}, expected } = 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);
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expectedArray = expected ?? wrapExpectedWithArray(subject, children, expectedNumber);
+    const message = enhanceError(subject, expectedArray, children, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
         matcherName,
-        expectedValue: expectedValueOrOptions,
+        expectedValue,
         options,
         result
     });

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,10 +1,10 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { compareTextOrOneOf, 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);
+    return compareTextOrOneOf(actualLabel, label, options);
 }
 export async function toHaveComputedLabel(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'computed label', verb = 'have', isNot, matcherName = 'toHaveComputedLabel' } = this;
@@ -14,18 +14,16 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
         options,
     });
     expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
-    const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
             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 message = enhanceError(el, expected ?? wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,10 +1,10 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { compareTextOrOneOf, 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);
+    return compareTextOrOneOf(actualRole, role, options);
 }
 export async function toHaveComputedRole(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'computed role', verb = 'have', isNot, matcherName = 'toHaveComputedRole' } = this;
@@ -14,18 +14,16 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
         options,
     });
     expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
-    const { success: pass, actual: actualRole, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualRole, subject: el, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
             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 message = enhanceError(el, expected ?? wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveElementClass.js

@@ -1,6 +1,6 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { compareText, compareTextOrArray, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function singleElementCompare(el, attribute, value, options) {
     const actualClass = await el.getAttribute(attribute);
     if (value === undefined) {
@@ -13,17 +13,13 @@ async function singleElementCompare(el, attribute, value, options) {
         return compareText(actualClass, value, options);
     }
     const classes = actualClass.split(' ');
-    const isValueInClasses = classes.some((clazz) => {
-        return compareTextOrArray(clazz, value, options).success;
-    });
+    const values = Array.isArray(value) ? value : [value];
+    const isValueInClasses = classes.some((clazz) => values.some((expected) => compareText(clazz, expected, 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?.({
@@ -32,18 +28,17 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
         options,
     });
     const attribute = 'class';
-    const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: attr, subject: el, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
             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 message = enhanceError(el, expected ?? wrapExpectedWithArray(el, attr, expectedValue), attr, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveElementProperty.js

@@ -20,12 +20,8 @@ async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS)
     return compareText(propertyValue.toString(), expectedValue, options);
 }
 export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
-    const { expectation = 'property', verb = 'have', isNot, matcherName = 'toHaveElementProperty' } = this;
-    const paramsCount = arguments.length;
+    const { expectation = 'property', verb = 'have', isNot, matcherName = 'toHaveElementProperty', allowObjectExpectedValue = true } = this;
     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 = expect.anything();
     }
     await options.beforeAssertion?.({
@@ -34,7 +30,7 @@ export async function toHaveElementProperty(received, property, value, options =
         options,
     });
     value = buildWdioAsymmetricMatchersWithOptions(value, options);
-    const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {}, expected: expectedValues } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
@@ -43,11 +39,10 @@ export async function toHaveElementProperty(received, property, value, options =
                 return condition(element, property, expectedValue, options);
             },
             context: { isNot, iteration },
-            strategy: 'NewStrictMultipleElements',
-            strictConfiguration: { allowArrayWithSingleElement: false }
+            strictConfiguration: { allowArrayWithSingleElement: false, allowObjectExpectedValue }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
-    const expected = wrapExpectedWithArray(elements, actualProppertyValue, value);
+    const expected = expectedValues ?? wrapExpectedWithArray(elements, actualProppertyValue, value);
     const message = enhanceError(elements, expected, actualProppertyValue, { isNot, isSome }, verb, expectation, property, options);
     const result = {
         pass,

package/lib/matchers/element/toHaveHTML.js

@@ -1,32 +1,30 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { compareTextOrOneOf, 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);
-    return compareTextOrArray(actualHTML, html, options);
+    return compareTextOrOneOf(actualHTML, html, options);
 }
 export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'HTML', verb = 'have', isNot, matcherName = 'toHaveHTML' } = this;
-    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
     await options.beforeAssertion?.({
         matcherName,
         expectedValue,
         options,
     });
-    const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const expectedWithOptions = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         const result = await executeCommandWithStrategy({
             unresolvedElements: received,
             supportsArrayContaining: true,
-            expectedValues: expectedValue,
+            expectedValues: expectedWithOptions,
             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 expectedValues = expected ?? wrapExpectedWithArray(elements, actualHTML, expectedWithOptions);
     const message = enhanceError(elements, expectedValues, actualHTML, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveHeight.js

@@ -1,7 +1,7 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { wrapExpectedWithArray } from '../../util/elementsUtil.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { validateNumberMatcherArray } from '../../util/numberOptionsUtil.js';
 import { enhanceError, waitUntil, } from '../../utils.js';
 async function condition(el, expectedNumber) {
     const actualHeight = await el.getSize('height');
@@ -17,19 +17,18 @@ export async function toHaveHeight(received, expectedValue, options = DEFAULT_OP
         expectedValue,
         options,
     });
-    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
-    const { success: pass, actual: actualHeight, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const expectedNumber = validateNumberMatcherArray(expectedValue);
+    const { success: pass, actual: actualHeight, subject: elements, context: { isSome } = {}, expected } = 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);
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expectedValues = expected ?? wrapExpectedWithArray(elements, actualHeight, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualHeight, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveHref.js

@@ -1,18 +1,21 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toHaveHref(el, expectedValue, options = DEFAULT_OPTIONS) {
+    const { matcherName = 'toHaveHref' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveHref',
+        matcherName,
         expectedValue,
         options,
     });
     const result = await toHaveAttributeAndValue.call(this, el, 'href', expectedValue, options);
     await options.afterAssertion?.({
-        matcherName: 'toHaveHref',
+        matcherName,
         expectedValue,
         options,
         result
     });
     return result;
 }
-export const toHaveLink = toHaveHref;
+export const toHaveLink = function toHaveLink(...args) {
+    return toHaveHref.call({ matcherName: 'toHaveLink', ...this }, ...args);
+};

package/lib/matchers/element/toHaveId.js

@@ -1,14 +1,15 @@
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toHaveId(el, expectedValue, options = DEFAULT_OPTIONS) {
+    const { matcherName = 'toHaveId' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveId',
+        matcherName,
         expectedValue,
         options,
     });
     const result = await toHaveAttributeAndValue.call(this, el, 'id', expectedValue, options);
     await options.afterAssertion?.({
-        matcherName: 'toHaveId',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveSize.js

@@ -12,17 +12,16 @@ export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTI
         expectedValue,
         options,
     });
-    const { success: pass, actual: actualSize, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualSize, subject: el, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedSize) => condition(element, expectedSize),
             context: { isNot, iteration },
-            strategy: 'NewStrictMultipleElements',
-            strictConfiguration: { allowArrayWithSingleElement: false }
+            strictConfiguration: { allowArrayWithSingleElement: false, allowObjectExpectedValue: true }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, { isNot, isSome }, verb, expectation, '', options);
+    const message = enhanceError(el, expected ?? wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveStyle.js

@@ -14,17 +14,16 @@ export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPT
         expectedValue,
         options,
     });
-    const { success: pass, actual: actualStyle, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualStyle, subject: el, context: { isSome } = {}, expected: expectedValues } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValues) => condition(element, expectedValues, options),
             context: { isNot, iteration },
-            strategy: 'NewStrictMultipleElements',
-            strictConfiguration: { allowArrayWithSingleElement: false }
+            strictConfiguration: { allowArrayWithSingleElement: false, allowObjectExpectedValue: true }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
-    const expected = wrapExpectedWithArray(el, actualStyle, expectedValue);
+    const expected = expectedValues ?? wrapExpectedWithArray(el, actualStyle, expectedValue);
     const message = enhanceError(el, expected, actualStyle, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,

package/lib/matchers/element/toHaveText.js

@@ -1,11 +1,11 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareTextOrArray, enhanceError, getFeatureFlagValue, isArrayContainingMatcher, waitUntil, } from '../../utils.js';
+import { compareTextOrOneOf, enhanceError, isArrayContainingMatcher, waitUntil, } from '../../utils.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
 import { fillSingleExpectedForElementArray } from '../../util/elementsUtil.js';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
 async function compareElement(el, expectedText, options) {
     const actualText = await el.getText();
-    return compareTextOrArray(actualText, expectedText, options);
+    return compareTextOrOneOf(actualText, expectedText, options);
 }
 export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'text', verb = 'have', isNot, matcherName = 'toHaveText' } = this;
@@ -15,8 +15,7 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
         options,
     });
     expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
-    const isNewStrictCompare = getFeatureFlagValue(options, 'useToHaveTextStrictMultiElementsCompareStrategy');
-    const { success: pass, actual: actualText, subject: subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualText, subject, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
@@ -25,15 +24,13 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
                 return compareElement(element, values, options);
             },
             context: { isNot, iteration },
-            strategy: isNewStrictCompare ? 'NewStrictMultipleElements' : 'LegacyLooseMultipleElements',
-            strictConfiguration: { allowArrayWithSingleElement: true }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
     if (isArrayContainingMatcher(expectedValue) && actualText === undefined) {
         throw new Error('toHaveText with arrayContaining requires an array of elements');
     }
-    const expected = fillSingleExpectedForElementArray(subject, expectedValue);
-    const message = enhanceError(subject, expected, actualText, { isNot, isSome }, verb, expectation, '', options);
+    const finalExpected = expected ?? fillSingleExpectedForElementArray(subject, expectedValue);
+    const message = enhanceError(subject, finalExpected, actualText, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveValue.js

@@ -1,5 +1,5 @@
 import { toHaveElementProperty } from './toHaveElementProperty.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export function toHaveValue(el, value, options = DEFAULT_OPTIONS) {
-    return toHaveElementProperty.call(this, el, 'value', value, options);
+    return toHaveElementProperty.call({ matcherName: 'toHaveValue', ...this, allowObjectExpectedValue: false }, el, 'value', value, options);
 }

package/lib/matchers/element/toHaveWidth.js

@@ -1,7 +1,7 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { wrapExpectedWithArray } from '../../util/elementsUtil.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { validateNumberMatcherArray } from '../../util/numberOptionsUtil.js';
 import { enhanceError, waitUntil, } from '../../utils.js';
 async function condition(el, expectedNumber) {
     const actualWidth = await el.getSize('width');
@@ -17,19 +17,18 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
         expectedValue,
         options,
     });
-    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
-    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const expectedNumber = validateNumberMatcherArray(expectedValue);
+    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {}, expected } = 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, actualWidth, expectedNumber);
-    const message = enhanceError(elements, expectedValues, actualWidth, { isNot, isSome }, verb, expectation, '', commandOptions);
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expectedValues = expected ?? wrapExpectedWithArray(elements, actualWidth, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualWidth, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,8 +1,9 @@
 import { waitUntil, enhanceError, } from '../../utils.js';
-import { refetchElements, syncronizeElements } from '../../util/refetchElements.js';
+import { refetchElements, synchronizeElementArray, syncronizeElements } from '../../util/refetchElements.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
-import { awaitElementArray, isStrictlyElementArray } from '../../util/elementsUtil.js';
+import { validateNumberMatcher } from '../../util/numberOptionsUtil.js';
+import { awaitElementArray, isMultiRemoteElementArray, isMultiRemoteElements, isMultiRemoteElementsLike, isStrictlyElementArray } from '../../util/elementsUtil.js';
+import { getElementsPerInstance, getGlobalMultiRemoteInstanceNames, hasSameInstanceNames, isGlobalBrowserSingleRemote, isMultiRemoteMatcher } from '../../util/multiRemoteUtils.js';
 export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'elements array of size', verb = 'be', isNot, matcherName = 'toBeElementsArrayOfSize' } = this;
     await options.beforeAssertion?.({
@@ -10,8 +11,17 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
         expectedValue,
         options,
     });
-    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
     let { elements, other } = await awaitElementArray(received);
+    const awaitedMultiRemote = other ?? elements;
+    const isEmptyWithPerInstanceSizes = Array.isArray(awaitedMultiRemote) && awaitedMultiRemote.length === 0
+        && !isStrictlyElementArray(awaitedMultiRemote) && !isGlobalBrowserSingleRemote()
+        && getPerInstanceSizes(expectedValue) !== undefined;
+    if (isMultiRemoteElementsLike(awaitedMultiRemote) || isEmptyWithPerInstanceSizes) {
+        const result = await multiRemoteElementsArrayOfSize(awaitedMultiRemote, expectedValue, options, { context: this, verb, expectation });
+        await options.afterAssertion?.({ matcherName, expectedValue, options, result });
+        return result;
+    }
+    const expectedNumber = validateNumberMatcher(expectedValue);
     const originalLength = elements ? elements.length : undefined;
     const { success: pass } = await waitUntil(async (iteration) => {
         if (!elements) {
@@ -25,12 +35,12 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
             return { success: isPassing, subject: elements, actual: elements.length };
         }
         return { success: false, subject: elements, actual: elements.length };
-    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    }, isNot, { wait: options.wait, interval: options.interval });
     if (pass && originalLength !== undefined && elements !== received && (isStrictlyElementArray(received) || received instanceof Promise) && isStrictlyElementArray(elements)) {
         await syncronizeElements(received, elements);
     }
     const actual = originalLength;
-    const message = enhanceError(elements ?? other, expectedNumber, actual, this, verb, expectation, '', commandOptions);
+    const message = enhanceError(elements ?? other, expectedNumber, actual, this, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
@@ -43,3 +53,58 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
     });
     return result;
 }
+const multiRemoteElementsArrayOfSize = async (received, expectedValue, options, { context, verb, expectation }) => {
+    const { isNot } = context;
+    const perInstanceSizes = getPerInstanceSizes(expectedValue);
+    const instances = getMultiRemoteInstanceNames(received)
+        ?? getGlobalMultiRemoteInstanceNames()
+        ?? (perInstanceSizes ? Object.keys(perInstanceSizes) : []);
+    let expected;
+    let instanceMismatch = false;
+    if (perInstanceSizes) {
+        instanceMismatch = !hasSameInstanceNames(perInstanceSizes, instances);
+        expected = Object.fromEntries(Object.entries(perInstanceSizes).map(([name, value]) => [name, validateNumberMatcher(value)]));
+    }
+    else {
+        const numberMatcher = validateNumberMatcher(expectedValue);
+        expected = Object.fromEntries(instances.map((name) => [name, numberMatcher]));
+    }
+    let refetchSource = received;
+    let elements = received;
+    let actual = countElementsPerInstance(elements, instances);
+    const { success: pass } = await waitUntil(async (iteration) => {
+        if (iteration > 0) {
+            elements = await refetchElements(refetchSource);
+            if (elements.length > 0 || !isMultiRemoteElements(refetchSource)) {
+                refetchSource = elements;
+            }
+            actual = countElementsPerInstance(elements, instances);
+        }
+        if (instanceMismatch) {
+            return { success: !!isNot, subject: refetchSource, actual, abort: true };
+        }
+        const matches = (name) => expected[name].asymmetricMatch(actual[name]);
+        const success = isNot ? instances.some(matches) : instances.every(matches);
+        return { success, subject: refetchSource, actual };
+    }, isNot, { wait: options.wait, interval: options.interval });
+    if (pass && elements !== received) {
+        synchronizeElementArray(received, elements);
+    }
+    const message = enhanceError(refetchSource, expected, actual, { isNot }, verb, expectation, '', options);
+    return { pass, message: () => message };
+};
+const getPerInstanceSizes = (value) => {
+    return isMultiRemoteMatcher(value) ? value.sample : undefined;
+};
+const getMultiRemoteInstanceNames = (elements) => {
+    const first = elements[0];
+    if (first) {
+        return first.instances;
+    }
+    const parent = isMultiRemoteElementArray(elements) ? elements.parent : undefined;
+    return parent?.instances;
+};
+const countElementsPerInstance = (elements, instances) => {
+    const elementsPerInstance = getElementsPerInstance(elements, instances);
+    return Object.fromEntries(instances.map((name) => [name, elementsPerInstance[name].length]));
+};

package/lib/matchers/mock/toBeRequested.js

@@ -1,5 +1,5 @@
 import { toBeRequestedTimes } from './toBeRequestedTimes.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export function toBeRequested(received, options = DEFAULT_OPTIONS) {
-    return toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { gte: 1 }, options);
+    return toBeRequestedTimes.call({ matcherName: 'toBeRequested', ...(this || {}), expectation: 'called' }, received, { gte: 1 }, options);
 }