expect-webdriverio 5.6.9 → 6.0.0

package/README.md

@@ -7,15 +7,20 @@
 
 ## Key Features
 
-- [waits](#default-options) for expectation to succeed
-- detailed [error messages](#error-messages)
-- works in Mocha, Cucumber, Jest, Jasmine
-- builtin [types](docs/Types.md) for TypeScript and JS autocompletion
+- [Waits](#default-options) for expectation to succeed
+- Support single element & multi-elements
+- Detailed [error messages](#error-messages)
+- Works in Mocha, Cucumber, Jest, Jasmine
+- Builtin [types](docs/Types.md) for TypeScript and JS autocompletion
 
 ## Installation
 
-1. `npm install expect` (**Jasmine** and **Jest** users should skip this step)
-2. `npm install expect-webdriverio`
+1. `npm install expect-webdriverio`
+2. Install your test framework adapter (if not already set up via WDIO testrunner):
+   - **Mocha** (default): `npm install @wdio/mocha-framework`
+   - **Jasmine**: `npm install @wdio/jasmine-framework`
+   - **Cucumber**: `npm install @wdio/cucumber-framework`
+   - **Jest**: No adapter needed — see [Jest Framework section](docs/Framework.md#jest)
 
 NOTE: [WebdriverIO](https://github.com/webdriverio/webdriverio) `v9.0.0` or higher is required!
 
@@ -26,15 +31,15 @@ NOTE: [WebdriverIO](https://github.com/webdriverio/webdriverio) `v9.0.0` or high
 If you run your tests through the [WDIO testrunner](https://webdriver.io/docs/clioptions) no additional setup is needed. WebdriverIO initialises `expect-webdriverio` and makes `expect` available in the global scope. So you can use it directly in your tests:
 
 ```js
-const $button = await $('button')
-await expect($button).toBeDisplayed()
+const button = await $('button')
+await expect(button).toBeDisplayed()
 ```
 
 See more [Examples](docs/Examples.md)
 
 ### Using in a standalone script
 
-If you embed WebdriverIO in a standalone script, make sure you import `expect-webdriverio` before you use it anywhere.
+If you embed WebdriverIO in a standalone (without `@wdio/globals`), make sure you import `expect-webdriverio` before you use it anywhere.
 
 ```js
 import { remote } from 'webdriverio'
@@ -77,8 +82,5 @@ First of all, **feel free to raise an issue with your suggestions or help with P
 
 ### Planned
 
-- css matcher
-- size matcher
-- cookie / localStorage matchers?
-- text regex matchers
-- multiremote support (if requested)
+- cookie
+- multiremote support (coming)

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

@@ -1,7 +1,16 @@
 /// <reference types="./types/expect-webdriverio.d.ts"/>
 
-declare namespace jasmine {
+/**
+ * Note: Under development, until proven, expect breaking changes!
+ * Augment the Jasmine namespace to match the behavior of `@wdio/jasmine-framework`.
+ * Only custom WDIO matchers are available under `expectAsync`, as well as Jasmine's built-in matchers.
+ * `expectAsync` is forced into the `expect` global ambient, making all Jasmine sync-matchers asynchronous.
+ *
+ * When using `@wdio/jasmine-framework`, specify `expect-webdriverio/jasmine-wdio-expect-async` in the tsconfig.json's types.
+ * TODO move into `@wdio/jasmine-framework` and deprecated it from `expect-webdriverio`.
+ */
 
+declare namespace jasmine {
     /**
      * Async matchers for Jasmine to allow the typing of `expectAsync` with WebDriverIO matchers.
      * T is the type of the actual value
@@ -10,28 +19,47 @@ declare namespace jasmine {
      *
      * We force Matchers to return a `Promise<void>` since Jasmine's `expectAsync` expects a promise in all cases (different from Jest)
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface AsyncMatchers<T, U> extends Omit<ExpectWebdriverIO.Matchers<Promise<void>, T>, 'toMatchSnapshot' | 'toMatchInlineSnapshot'> {
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- U is required to properly override Jasmine's AsyncMatchers
+    interface AsyncMatchers<T, U> extends ExpectWebdriverIO.Matchers<Promise<void>, T> {
         /**
-         * snapshot matcher
-         * @param label optional snapshot label
+         * Override to unwrap Promise<T> since `expect` replaces `expectAsync` under @wdio/jasmine-framework.
+         * Without this, toBeResolvedTo expects Expected<Promise<X>> instead of Expected<X>.
          */
-        toMatchSnapshot(label?: string): Promise<void>;
+        toBeResolvedTo(expected: Expected<T extends PromiseLike<infer V> ? V : T>): PromiseLike<void>;
+
         /**
-         * inline snapshot matcher
-         * @param snapshot snapshot string (autogenerated if not specified)
-         * @param label optional snapshot label
+         * Rejection type is unknown since promises can reject with any value.
          */
-        toMatchInlineSnapshot(snapshot?: string, label?: string): Promise<void>;
+        toBeRejectedWith(expected: unknown): PromiseLike<void>;
     }
+
+    // Needed to reference it below for the withContext method
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Matchers<T> {}
 }
 
-/**
- * Overrides the default WDIO expect specifically for Jasmine, since `expectAsync` is forced into `expect`, making all matchers fully asynchronous. This is not the case under Jest or Mocha.
- * Using `jasmine.AsyncMatchers` pull on WdioMatchers above but also allow to using Jasmine's built-in matchers and also `withContext` matcher.
- */
 declare namespace ExpectWebdriverIO {
-    interface Expect {
+
+    // Should be the same as https://github.com/webdriverio/webdriverio/blob/ea0e3e00288abced4c739ff9e46c46977b7cdbd2/packages/wdio-jasmine-framework/src/index.ts#L21-L29
+    interface JasmineAsymmetricMatchers extends Pick<ExpectWebdriverIO.AsymmetricMatchers, 'any' | 'anything' | 'arrayContaining' | 'objectContaining' | 'stringContaining' | 'stringMatching'> {}
+
+    // Hack to convert all sync matchers to return Promise<void> since `wdio/jasmine-framework` forces `expect` to be async
+    type JasmineSyncMatchers<T> = {
+        [K in keyof jasmine.Matchers<T>]: K extends 'not'
+            ? JasmineSyncMatchers<T>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            : jasmine.Matchers<T>[K] extends (...args: any) => any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ? (...args: any[]) => Promise<void>
+                : jasmine.Matchers<T>[K]
+    }
+
+    /**
+     * Overrides the default WDIO expect specifically for Jasmine, since `expectAsync` is forced into `expect`, making all matchers fully asynchronous. This is not the case under Jest or Mocha.
+     * Using `jasmine.AsyncMatchers` includes the WdioMatchers from above, but also allows using Jasmine's built-in matchers and the `withContext` matcher.
+     */
+    interface JasmineExpect extends ExpectWebdriverIO.JasmineAsymmetricMatchers, ExpectLibInverse<ExpectWebdriverIO.JasmineAsymmetricMatchers> {
         /**
          * The `expect` function is used every time you want to test a value.
          * You will rarely call `expect` by itself.
@@ -40,10 +68,22 @@ declare namespace ExpectWebdriverIO {
          *  - T: the type of the actual value, e.g. any type, not just WebdriverIO.Browser or WebdriverIO.Element
          *  - R: the type of the return value, e.g. Promise<void> or void
          *
-         * Note: The function must stay here in the namespace to overwrite correctly the expect function from the expect library.
-         *
          * @param actual The value to apply matchers against.
          */
-        <T = unknown>(actual: T): jasmine.AsyncMatchers<T, void>
+        <T = unknown>(actual: T): {
+            withContext(message: string): jasmine.AsyncMatchers<T, Promise<void>> & JasmineSyncMatchers<T>;
+        } & jasmine.AsyncMatchers<T, Promise<void>> & JasmineSyncMatchers<T>
+    }
+}
+
+/**
+ * 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!
+declare const expect: ExpectWebdriverIO.JasmineExpect
+declare namespace NodeJS {
+    interface Global {
+        expect: ExpectWebdriverIO.JasmineExpect
     }
 }

package/jasmine.d.ts

@@ -1,27 +1,20 @@
 /// <reference types="./types/expect-webdriverio.d.ts"/>
 
+/**
+ * Augment the Jasmine namespace to include the WDIO custom async matchers only.
+ * When using the vanilla Jasmine Library, use `jasmine.addAsyncMatchers(wdioCustomMatchers)` and specify `expect-webdriverio/jasmine` in the tsconfig.json's types.
+ */
+
 declare namespace jasmine {
 
     /**
-     * Async matchers for Jasmine to allow the typing of `expectAsync` with WebDriverIO matchers.
+     * Async matchers for Jasmine to allow the typing of `expectAsync` with WebDriverIO custom matchers.
      * T is the type of the actual value
      * U is the type of the expected value
      * Both T,U must stay named as they are to override the default `AsyncMatchers` type from Jasmine.
      *
-     * We force Matchers to return a `Promise<void>` since Jasmine's `expectAsync` expects a promise in all cases (different from Jest)
+     * We force Matchers to return a `Promise<void>` since under Jasmine's `expectAsync` everything is a promise.
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface AsyncMatchers<T, U> extends Omit<ExpectWebdriverIO.Matchers<Promise<void>, T>, 'toMatchSnapshot' | 'toMatchInlineSnapshot'> {
-        /**
-         * snapshot matcher
-         * @param label optional snapshot label
-         */
-        toMatchSnapshot(label?: string): Promise<void>;
-        /**
-         * inline snapshot matcher
-         * @param snapshot snapshot string (autogenerated if not specified)
-         * @param label optional snapshot label
-         */
-        toMatchInlineSnapshot(snapshot?: string, label?: string): Promise<void>;
-    }
-}
+    interface AsyncMatchers<T, U> extends ExpectWebdriverIO.Matchers<Promise<void>, T> {}
+}

package/lib/constants.js

@@ -1,8 +1,12 @@
+export const DEFAULT_FEATURE_FLAGS = {
+    useToHaveTextStrictMultiElementsCompareStrategy: false
+};
 export const DEFAULT_OPTIONS = {
     wait: 2000,
     interval: 100,
     beforeAssertion: async () => { },
     afterAssertion: async () => { },
+    featureFlags: DEFAULT_FEATURE_FLAGS
 };
 export const DEFAULT_OPTIONS_TO_BE_DISPLAYED = {
     ...DEFAULT_OPTIONS,

package/lib/index.js

@@ -3,41 +3,45 @@ import * as wdioMatchers from './matchers.js';
 import { DEFAULT_OPTIONS, defaultOptionsList } from './constants.js';
 import createSoftExpect from './softExpect.js';
 import { SoftAssertService } from './softAssert.js';
+import { oneOf } from './matchers/asymmetrics/oneOf.js';
+import { some as wdioSome } from './matchers/modifiers/some.js';
 export const wdioCustomMatchers = {};
 export const matchers = new Map();
-const filteredMatchers = {};
 const extend = expectLib.extend;
-Object.keys(wdioMatchers).forEach(matcher => {
-    if (typeof wdioMatchers[matcher] === 'function') {
-        filteredMatchers[matcher] = wdioMatchers[matcher];
-    }
-});
-expectLib.extend = (m) => {
-    if (!m || typeof m !== 'object') {
+expectLib.extend = (extendedMatchers) => {
+    if (!extendedMatchers || typeof extendedMatchers !== 'object') {
         return;
     }
-    Object.entries(m).forEach(([name, matcher]) => {
+    Object.entries(extendedMatchers).forEach(([name, matcher]) => {
         wdioCustomMatchers[name] = matcher;
         matchers.set(name, matcher);
     });
-    return extend(m);
+    return extend(extendedMatchers);
 };
-expectLib.extend(filteredMatchers);
-const expectWithSoft = expectLib;
-Object.defineProperty(expectWithSoft, 'soft', {
+const filteredWdioMatchers = {};
+Object.entries(wdioMatchers).forEach(([matcher, value]) => {
+    if (typeof value === 'function') {
+        filteredWdioMatchers[matcher] = value;
+    }
+});
+const wdioExpect = expectLib;
+wdioExpect.extend(filteredWdioMatchers);
+wdioExpect.oneOf = oneOf;
+Object.defineProperty(wdioExpect, 'soft', {
     value: (actual) => createSoftExpect(actual)
 });
-Object.defineProperty(expectWithSoft, 'getSoftFailures', {
+Object.defineProperty(wdioExpect, 'getSoftFailures', {
     value: (testId) => SoftAssertService.getInstance().getFailures(testId)
 });
-Object.defineProperty(expectWithSoft, 'assertSoftFailures', {
+Object.defineProperty(wdioExpect, 'assertSoftFailures', {
     value: (testId) => SoftAssertService.getInstance().assertNoFailures(testId)
 });
-Object.defineProperty(expectWithSoft, 'clearSoftFailures', {
+Object.defineProperty(wdioExpect, 'clearSoftFailures', {
     value: (testId) => SoftAssertService.getInstance().clearFailures(testId)
 });
-export const expect = expectWithSoft;
-export const getConfig = () => DEFAULT_OPTIONS;
+export const expect = wdioExpect;
+export const some = wdioSome;
+export const getDefaultOptions = () => DEFAULT_OPTIONS;
 export const setDefaultOptions = (options) => {
     Object.entries(options).forEach(([key, value]) => {
         defaultOptionsList.forEach((option) => {
@@ -47,7 +51,15 @@ 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,11 +11,12 @@ function asymmetricMatch(a, b) {
     if (asymmetricA && asymmetricB) {
         return undefined;
     }
+    const matchersUtil = { equals, contains: equals };
     if (asymmetricA) {
-        return a.asymmetricMatch(b);
+        return a.asymmetricMatch(b, matchersUtil);
     }
     if (asymmetricB) {
-        return b.asymmetricMatch(a);
+        return b.asymmetricMatch(a, matchersUtil);
     }
 }
 function eq(a, b, aStack, bStack, customTesters, hasKey) {

package/lib/matchers/asymmetrics/asymmetricsUtils.js

@@ -0,0 +1,24 @@
+import { AsymmetricMatcher } from 'expect';
+import { isAsymmetricMatcher } from '../../utils.js';
+export const buildWdioAsymmetricMatchersWithOptions = (expectedValue, options) => {
+    if (options) {
+        if (Array.isArray(expectedValue)) {
+            return expectedValue.map((value) => buildOneAsymmetricMatcherWithOptions(value, options));
+        }
+        return buildOneAsymmetricMatcherWithOptions(expectedValue, options);
+    }
+    return expectedValue;
+};
+const buildOneAsymmetricMatcherWithOptions = (expectedValue, options) => {
+    if (options) {
+        if (isAsymmetricMatcher(expectedValue) && 'withOptions' in expectedValue && typeof expectedValue.withOptions === 'function') {
+            return expectedValue.withOptions(options);
+        }
+    }
+    return expectedValue;
+};
+export class WdioAsymmetricMatchers extends AsymmetricMatcher {
+    toString() {
+        return this.toAsymmetricMatcher();
+    }
+}

package/lib/matchers/asymmetrics/oneOf.js

@@ -0,0 +1,51 @@
+import { compareTextWithArray } from '../../utils.js';
+import { WdioAsymmetricMatchers } from './asymmetricsUtils.js';
+export class OneOfMatcher extends WdioAsymmetricMatchers {
+    options = {};
+    constructor(...sample) {
+        super(sample);
+    }
+    setOptions(options) {
+        this.options = options;
+        return this;
+    }
+    asymmetricMatch(actual) {
+        if (actual === null) {
+            return this.sample.includes(null);
+        }
+        else if (typeof actual !== 'string') {
+            return false;
+        }
+        return compareTextWithArray(actual, this.sample.filter(s => s !== null), this.options).success;
+    }
+    withOptions(options) {
+        return new OneOfMatcher(...this.sample).setOptions(options);
+    }
+    toAsymmetricMatcher() {
+        let prefix = '';
+        if (this.options.containing) {
+            prefix = 'containing';
+        }
+        else if (this.options.atStart) {
+            prefix = 'startingWith';
+        }
+        else if (this.options.atEnd) {
+            prefix = 'endingWith';
+        }
+        else if (typeof this.options.atIndex === 'number') {
+            prefix = `matchingAtIndex<${this.options.atIndex}>`;
+        }
+        const isArray = Array.isArray(this.sample);
+        const samples = isArray ? this.sample : [this.sample];
+        const formattedSamples = samples
+            .map((s) => (s instanceof RegExp ? s.toString() : `"${s}"`))
+            .join(', ');
+        if (isArray) {
+            prefix = prefix ? prefix + 'OneOf' : 'oneOf';
+        }
+        return prefix ? `${prefix}<${formattedSamples}>` : formattedSamples;
+    }
+}
+export function oneOf(...sample) {
+    return new OneOfMatcher(...sample);
+}

package/lib/matchers/browser/toHaveClipboardText.js

@@ -3,27 +3,26 @@ import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 const log = logger('expect-webdriverio');
 export async function toHaveClipboardText(browser, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'clipboard text', verb = 'have' } = this;
+    const { expectation = 'clipboard text', verb = 'have', isNot, matcherName = 'toHaveClipboardText' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveClipboardText',
+        matcherName,
         expectedValue,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
+    const { actual, success: pass } = await waitUntil(async () => {
         await browser.setPermissions({ name: 'clipboard-read' }, 'granted')
             .catch((err) => log.warn(`Couldn't set clipboard permissions: ${err}`));
-        actual = await browser.execute(() => window.navigator.clipboard.readText());
-        return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+        const actual = await browser.execute(() => window.navigator.clipboard.readText());
+        const compareResult = compareText(actual, expectedValue, options);
+        return { actual, success: compareResult.success, subject: browser };
+    }, isNot, { wait: options.wait, interval: options.interval });
     const message = enhanceError('browser', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveClipboardText',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/browser/toHaveLocalStorageItem.js

@@ -1,33 +1,41 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { expect } from '../../index.js';
 export async function toHaveLocalStorageItem(browser, key, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'localStorage item', verb = 'have' } = this;
+    const { expectation = 'localStorage item', verb = 'have', isNot, matcherName = 'toHaveLocalStorageItem' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveLocalStorageItem',
+        matcherName,
         expectedValue: expectedValue ? [key, expectedValue] : key,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
-        actual = await browser.execute((storageKey) => {
+    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 { actual, success: pass } = await waitUntil(async () => {
+        const actual = await browser.execute((storageKey) => {
             return localStorage.getItem(storageKey);
         }, key);
-        if (expectedValue === undefined) {
-            return actual !== null;
-        }
         if (actual === null) {
-            return false;
+            return { actual, success: false, subject: browser };
         }
-        return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
-    const message = enhanceError('browser', expectedValue !== undefined ? expectedValue : `localStorage item "${key}"`, actual, this, verb, expectation, key, options);
+        const compareResult = compareText(actual, expected, options);
+        return { actual, success: compareResult.success, subject: browser };
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError('browser', expected, actual, this, verb, expectation, key, options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveLocalStorageItem',
+        matcherName,
         expectedValue: expectedValue ? [key, expectedValue] : key,
         options,
         result

package/lib/matchers/browser/toHaveTitle.js

@@ -1,25 +1,24 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toHaveTitle(browser, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'title', verb = 'have' } = this;
+    const { expectation = 'title', verb = 'have', isNot, matcherName = 'toHaveTitle' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveTitle',
+        matcherName,
         expectedValue,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
-        actual = await browser.getTitle();
-        return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+    const { actual, success } = await waitUntil(async () => {
+        const actual = await browser.getTitle();
+        const compareResult = compareText(actual, expectedValue, options);
+        return { actual, success: compareResult.success, subject: browser };
+    }, isNot, { wait: options.wait, interval: options.interval });
     const message = enhanceError('window', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
-        pass,
+        pass: success,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveTitle',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/browser/toHaveUrl.js

@@ -1,25 +1,24 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toHaveUrl(browser, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'url', verb = 'have' } = this;
+    const { expectation = 'url', verb = 'have', isNot, matcherName = 'toHaveUrl' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveUrl',
+        matcherName,
         expectedValue,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
-        actual = await browser.getUrl();
-        return compareText(actual, expectedValue, options).result;
-    }, isNot, options);
+    const { success: pass, actual } = await waitUntil(async () => {
+        const actual = await browser.getUrl();
+        const compareResult = compareText(actual, expectedValue, options);
+        return { actual, success: compareResult.success, subject: browser };
+    }, isNot, { wait: options.wait, interval: options.interval });
     const message = enhanceError('window', expectedValue, actual, this, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveUrl',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toBeExisting.js

@@ -1,8 +1,9 @@
-import { executeCommandBe, aliasFn } from '../../utils.js';
+import { executeCommandBe } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export async function toExist(received, options = DEFAULT_OPTIONS) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
+    this.allowEmptyElements = true;
     await options.beforeAssertion?.({
         matcherName: 'toExist',
         options,
@@ -16,8 +17,12 @@ export async function toExist(received, options = DEFAULT_OPTIONS) {
     return result;
 }
 export function toBeExisting(el, options) {
-    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
+    this.expectation = 'existing';
+    this.verb = 'be';
+    return toExist.call(this, el, options);
 }
 export function toBePresent(el, options) {
-    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
+    this.expectation = 'present';
+    this.verb = 'be';
+    return toExist.call(this, el, options);
 }

package/lib/matchers/element/toBeSelected.js

@@ -2,29 +2,22 @@ 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';
     await options.beforeAssertion?.({
-        matcherName: 'toBeSelected',
+        matcherName: this.matcherName,
         options,
     });
     const result = await executeCommandBe.call(this, received, el => el?.isSelected(), options);
     await options.afterAssertion?.({
-        matcherName: 'toBeSelected',
+        matcherName: this.matcherName,
         options,
         result
     });
     return result;
 }
-export async function toBeChecked(el, options = DEFAULT_OPTIONS) {
+export async function toBeChecked(received, options = DEFAULT_OPTIONS) {
     this.expectation = 'checked';
-    await options.beforeAssertion?.({
-        matcherName: 'toBeChecked',
-        options,
-    });
-    const result = await toBeSelected.call(this, el, options);
-    await options.afterAssertion?.({
-        matcherName: 'toBeChecked',
-        options,
-        result
-    });
+    this.matcherName = 'toBeChecked';
+    const result = await toBeSelected.call(this, received, options);
     return result;
 }