expect-webdriverio 7.0.0 → 8.0.0-alpha.0

package/README.md

@@ -1,5 +1,9 @@
 # expect-webdriverio [![Test](https://github.com/webdriverio/expect-webdriverio/actions/workflows/test.yml/badge.svg)](https://github.com/webdriverio/expect-webdriverio/actions/workflows/test.yml)
 
+> [!IMPORTANT]
+> This branch is v8, in development for WebdriverIO v10. Its docs are not released yet.
+> For the latest release (v7, WebdriverIO v9), see the [v7 README](https://github.com/webdriverio/expect-webdriverio/blob/v7/README.md).
+
 ###### [API](docs/API.md) | [Multiple Elements](docs/MultipleElements.md) | [Multi-remote](docs/MultiRemote.md) | [TypeScript / JS Autocomplete](docs/Types.md) | [Examples](docs/Examples.md) | [Extending Matchers](docs/CustomMatchers.md)
 
 > [WebdriverIO](https://webdriver.io/) assertion library inspired by [expect](https://www.npmjs.com/package/expect)
@@ -31,7 +35,7 @@
 If you run your tests through the [WDIO testrunner](https://webdriver.io/docs/clioptions), no additional setup is needed. WebdriverIO initializes `expect-webdriverio` and makes `expect` available in the global scope so you can use it directly in your tests:
 
 ```js
-await expect($('button')).toBeDisplayed()
+await expect($('#submit')).toBeDisplayed()
 await expect($$('buttons')).toBeDisplayed()
 ```
 
@@ -46,7 +50,7 @@ await expect(multiRemoteBrowser).toHaveTitle('WebdriverIO')
 await expect(multiRemoteBrowser.$('h1')).toHaveText(expect.multiRemote({ chrome: 'Welcome', firefox: 'Bienvenue' }))
 ```
 
-Some feature flags and WebdriverIO environment variables are required or recommended, see [Multi-remote Support](docs/MultiRemote.md#requirements--configuration).
+Some WebdriverIO environment variables are recommended, see [Multi-remote Support](docs/MultiRemote.md#requirements--configuration).
 
 #### Local & Browser Runners
 - **Local Runner**: Fully compatible. You can leverage your test framework adapter as mentioned above.
@@ -69,7 +73,7 @@ import { expect } from 'expect-webdriverio'
 
     await browser.url('https://webdriver.io')
 
-    const $button = await browser.$('button')
+    const $button = await browser.$('.DocSearch-Button')
     await expect($button).toBeDisplayed()
     
     await browser.deleteSession()

package/jasmine-wdio-expect-async.d.ts

@@ -80,7 +80,7 @@ declare namespace ExpectWebdriverIO {
  * Under `@wdio/jasmine-framework`, the global `expect` is overridden to use Jasmine's `expectAsync`.
  * It contains custom WebdriverIO matchers as well as Jasmine's built-in async & sync matchers but not the basic Jest's expect library matchers.
  */
-// @ts-expect-error: IDE might flag this, but ignore it. This way the `tsc:root-types` can pass!
+// @ts-expect-error: the Jasmine `expect` is always loaded with this entry, so the two declarations conflict
 declare const expect: ExpectWebdriverIO.JasmineExpect
 declare namespace NodeJS {
     interface Global {

package/lib/constants.js

@@ -1,14 +1,10 @@
 import { getGlobalSingleton } from './util/globalSingleton.js';
 function createSharedConstants() {
-    const DEFAULT_FEATURE_FLAGS = {
-        useToHaveTextStrictMultiElementsCompareStrategy: false
-    };
     const DEFAULT_OPTIONS = {
         wait: 2000,
         interval: 100,
         beforeAssertion: async () => { },
         afterAssertion: async () => { },
-        featureFlags: DEFAULT_FEATURE_FLAGS
     };
     const DEFAULT_OPTIONS_TO_BE_DISPLAYED = {
         ...DEFAULT_OPTIONS,
@@ -18,14 +14,12 @@ function createSharedConstants() {
         visibilityProperty: true
     };
     return {
-        DEFAULT_FEATURE_FLAGS,
         DEFAULT_OPTIONS,
         DEFAULT_OPTIONS_TO_BE_DISPLAYED,
         defaultOptionsList: [DEFAULT_OPTIONS, DEFAULT_OPTIONS_TO_BE_DISPLAYED]
     };
 }
 const shared = getGlobalSingleton('constants', createSharedConstants);
-export const DEFAULT_FEATURE_FLAGS = shared.DEFAULT_FEATURE_FLAGS;
 export const DEFAULT_OPTIONS = shared.DEFAULT_OPTIONS;
 export const DEFAULT_OPTIONS_TO_BE_DISPLAYED = shared.DEFAULT_OPTIONS_TO_BE_DISPLAYED;
 export const defaultOptionsList = shared.defaultOptionsList;

package/lib/index.js

@@ -8,7 +8,6 @@ import { multiRemote } from './matchers/asymmetrics/multiRemote.js';
 import { getGlobalSingleton } from './util/globalSingleton.js';
 function createSharedExpectSetup() {
     const wdioCustomMatchers = {};
-    const matchers = new Map();
     const extend = expectLib.extend;
     expectLib.extend = (extendedMatchers) => {
         if (!extendedMatchers || typeof extendedMatchers !== 'object') {
@@ -16,7 +15,6 @@ function createSharedExpectSetup() {
         }
         Object.entries(extendedMatchers).forEach(([name, matcher]) => {
             wdioCustomMatchers[name] = matcher;
-            matchers.set(name, matcher);
         });
         return extend(extendedMatchers);
     };
@@ -46,11 +44,10 @@ function createSharedExpectSetup() {
         configurable: true,
         value: (testId) => SoftAssertService.getInstance().clearFailures(testId)
     });
-    return { wdioExpect, wdioCustomMatchers, matchers };
+    return { wdioExpect, wdioCustomMatchers };
 }
 const sharedExpectSetup = getGlobalSingleton('expect', createSharedExpectSetup);
 export const wdioCustomMatchers = sharedExpectSetup.wdioCustomMatchers;
-export const matchers = sharedExpectSetup.matchers;
 export const expect = sharedExpectSetup.wdioExpect;
 export const getDefaultOptions = () => DEFAULT_OPTIONS;
 export const setDefaultOptions = (options) => {
@@ -62,15 +59,6 @@ export const setDefaultOptions = (options) => {
         });
     });
 };
-export const setFeatureFlags = (featureFlags) => {
-    Object.entries(featureFlags).forEach(([ffName, ffValue]) => {
-        defaultOptionsList.forEach((option) => {
-            option.featureFlags[ffName] = ffValue;
-        });
-    });
-};
-export const setOptions = setDefaultOptions;
-export const getConfig = getDefaultOptions;
 export { SnapshotService } from './snapshot.js';
 export { SoftAssertService } from './softAssert.js';
 export { SoftAssertionService } from './softAssertService.js';

package/lib/jasmineUtils.js

@@ -11,10 +11,10 @@ function asymmetricMatch(a, b) {
     if (asymmetricA && asymmetricB) {
         return undefined;
     }
-    const matchersUtil = {
+    const matchersUtil = Object.assign([], {
         equals,
         contains: (actual, expected) => actual.some(value => equals(value, expected)),
-    };
+    });
     if (asymmetricA) {
         return a.asymmetricMatch(b, matchersUtil);
     }

package/lib/matchers/asymmetrics/oneOf.js

@@ -1,4 +1,4 @@
-import { compareTextWithArray } from '../../utils.js';
+import { compareText } from '../../utils.js';
 import { WdioAsymmetricMatchers } from './asymmetricsUtils.js';
 const ONE_OF_TAG = 'expect-webdriverio.oneOf';
 const ONE_OF_SYMBOL = Symbol.for(ONE_OF_TAG);
@@ -19,7 +19,7 @@ export class OneOfMatcher extends WdioAsymmetricMatchers {
         else if (typeof actual !== 'string') {
             return false;
         }
-        return compareTextWithArray(actual, this.sample.filter(s => s !== null), this.options).success;
+        return this.sample.some((expected) => expected !== null && compareText(actual, expected, this.options).success);
     }
     withOptions(options) {
         return new OneOfMatcher(...this.sample).setOptions(options);

package/lib/matchers/browser/toHaveClipboardText.js

@@ -1,9 +1,8 @@
-import logger from '@wdio/logger';
 import { waitUntil, enhanceError, compareTextOrOneOf } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeBrowserCommand } from '../../util/executeBrowserCommand.js';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
-const log = logger('expect-webdriverio');
+let permissionWarningLogged = false;
 export async function toHaveClipboardText(browser, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'clipboard text', verb = 'have', isNot, matcherName = 'toHaveClipboardText' } = this;
     await options.beforeAssertion?.({
@@ -35,7 +34,12 @@ export async function toHaveClipboardText(browser, expectedValue, options = DEFA
 }
 const compareClipboardText = async (browser, expectedValue, options) => {
     await browser.setPermissions({ name: 'clipboard-read' }, 'granted')
-        .catch((err) => log.warn(`Couldn't set clipboard permissions: ${err}`));
+        .catch((err) => {
+        if (!permissionWarningLogged) {
+            permissionWarningLogged = true;
+            console.warn(`expect-webdriverio: Couldn't set clipboard permissions: ${err}`);
+        }
+    });
     const actual = await browser.execute(() => window.navigator.clipboard.readText());
     return compareTextOrOneOf(actual, expectedValue, options);
 };

package/lib/matchers/browser/toHaveLocalStorageItem.js

@@ -10,17 +10,7 @@ export async function toHaveLocalStorageItem(browser, key, expectedValue, option
         expectedValue: expectedValue ? [key, expectedValue] : key,
         options,
     });
-    const paramsCount = arguments.length;
-    let expected;
-    if (expectedValue === undefined) {
-        if (paramsCount > 2) {
-            console.warn('[DEPRECATION] Using toHaveLocalStorageItem with undefined is deprecated in favor of expect.anything().');
-        }
-        expected = expect.anything();
-    }
-    else {
-        expected = expectedValue;
-    }
+    const expected = expectedValue ?? expect.anything();
     const expectedWithOptions = buildWdioAsymmetricMatchersWithOptions(expected, options);
     const { actual, success: pass, subject, expected: expectedValues } = await waitUntil(async () => {
         return await executeBrowserCommand({

package/lib/matchers/element/toBeClickable.js

@@ -2,13 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeClickable(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'clickable';
+    const { matcherName = 'toBeClickable' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeClickable',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isClickable(), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeClickable',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeDisabled.js

@@ -2,13 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeDisabled(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'disabled';
+    const { matcherName = 'toBeDisabled' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeDisabled',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeDisabled',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeDisplayed.js

@@ -2,8 +2,9 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS_TO_BE_DISPLAYED } from '../../constants.js';
 export async function toBeDisplayed(received, options = DEFAULT_OPTIONS_TO_BE_DISPLAYED) {
     this.expectation = this.expectation || 'displayed';
+    const { matcherName = 'toBeDisplayed' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeDisplayed',
+        matcherName,
         options,
     });
     const { withinViewport, contentVisibilityAuto, opacityProperty, visibilityProperty, ...commandOptions } = { ...DEFAULT_OPTIONS_TO_BE_DISPLAYED, ...options };
@@ -14,7 +15,7 @@ export async function toBeDisplayed(received, options = DEFAULT_OPTIONS_TO_BE_DI
         visibilityProperty
     }), commandOptions);
     await options.afterAssertion?.({
-        matcherName: 'toBeDisplayed',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -2,13 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeDisplayedInViewport(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'displayed in viewport';
+    const { matcherName = 'toBeDisplayedInViewport' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeDisplayedInViewport',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isDisplayed({ withinViewport: true }), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeDisplayedInViewport',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeEnabled.js

@@ -2,13 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeEnabled(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'enabled';
+    const { matcherName = 'toBeEnabled' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeEnabled',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isEnabled(), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeEnabled',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeExisting.js

@@ -4,13 +4,14 @@ export async function toExist(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
     this.allowEmptyElements = true;
+    const { matcherName = 'toExist' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toExist',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isExisting(), options);
     await options.afterAssertion?.({
-        matcherName: 'toExist',
+        matcherName,
         options,
         result
     });
@@ -19,10 +20,12 @@ export async function toExist(received, options = DEFAULT_OPTIONS) {
 export function toBeExisting(el, options) {
     this.expectation = 'existing';
     this.verb = 'be';
+    this.matcherName ??= 'toBeExisting';
     return toExist.call(this, el, options);
 }
 export function toBePresent(el, options) {
     this.expectation = 'present';
     this.verb = 'be';
+    this.matcherName ??= 'toBePresent';
     return toExist.call(this, el, options);
 }

package/lib/matchers/element/toBeFocused.js

@@ -2,13 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeFocused(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'focused';
+    const { matcherName = 'toBeFocused' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeFocused',
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isFocused(), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeFocused',
+        matcherName,
         options,
         result
     });

package/lib/matchers/element/toBeSelected.js

@@ -2,14 +2,14 @@ import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toBeSelected(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'selected';
-    this.matcherName = this.matcherName || 'toBeSelected';
+    const { matcherName = 'toBeSelected' } = this;
     await options.beforeAssertion?.({
-        matcherName: this.matcherName,
+        matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isSelected(), options);
     await options.afterAssertion?.({
-        matcherName: this.matcherName,
+        matcherName,
         options,
         result
     });
@@ -17,7 +17,7 @@ export async function toBeSelected(received, options = DEFAULT_OPTIONS) {
 }
 export async function toBeChecked(received, options = DEFAULT_OPTIONS) {
     this.expectation = 'checked';
-    this.matcherName = 'toBeChecked';
+    this.matcherName ??= 'toBeChecked';
     const result = await toBeSelected.call(this, received, options);
     return result;
 }

package/lib/matchers/element/toHaveAttribute.js

@@ -29,7 +29,6 @@ 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 = expectedValues ?? wrapExpectedWithArray(el, attr, expectedValue);
@@ -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,7 +1,6 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { isEmptyOrLegacyNumberOptions, validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
-import { isMultiRemoteMatcher } from '../../util/multiRemoteUtils.js';
+import { validateNumberMatcherArray } from '../../util/numberOptionsUtil.js';
 import { enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, expectedValue) {
     const children = await el.$$('./*').getElements();
@@ -13,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) && !isMultiRemoteMatcher(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 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 });
+    }, isNot, { wait: options.wait, interval: options.interval });
     const expectedArray = expected ?? wrapExpectedWithArray(subject, children, expectedNumber);
-    const message = enhanceError(subject, expectedArray, children, { isNot, isSome }, verb, expectation, '', commandOptions);
+    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

@@ -21,8 +21,6 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
             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, expected ?? wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, { isNot, isSome }, verb, expectation, '', options);

package/lib/matchers/element/toHaveComputedRole.js

@@ -21,8 +21,6 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
             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, expected ?? wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, { isNot, isSome }, verb, expectation, '', options);

package/lib/matchers/element/toHaveElementClass.js

@@ -1,6 +1,6 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { compareText, compareTextOrOneOf, 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 compareTextOrOneOf(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?.({
@@ -39,7 +35,6 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
             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 });

package/lib/matchers/element/toHaveElementProperty.js

@@ -21,11 +21,7 @@ async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS)
 }
 export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
     const { expectation = 'property', verb = 'have', isNot, matcherName = 'toHaveElementProperty', allowObjectExpectedValue = true } = 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 = expect.anything();
     }
     await options.beforeAssertion?.({
@@ -43,7 +39,6 @@ export async function toHaveElementProperty(received, property, value, options =
                 return condition(element, property, expectedValue, options);
             },
             context: { isNot, iteration },
-            strategy: 'NewStrictMultipleElements',
             strictConfiguration: { allowArrayWithSingleElement: false, allowObjectExpectedValue }
         });
     }, isNot, { wait: options.wait, interval: options.interval });

package/lib/matchers/element/toHaveHTML.js

@@ -8,25 +8,23 @@ async function singleElementCompare(el, 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 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 = expected ?? 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 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 });
+    }, isNot, { wait: options.wait, interval: options.interval });
     const expectedValues = expected ?? wrapExpectedWithArray(elements, actualHeight, expectedNumber);
-    const message = enhanceError(elements, expectedValues, actualHeight, { isNot, isSome }, verb, expectation, '', commandOptions);
+    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