expect-webdriverio 5.6.9 → 6.0.0

package/lib/utils.js

@@ -1,69 +1,68 @@
 import deepEql from 'deep-eql';
 import { expect } from 'expect';
-import { DEFAULT_OPTIONS } from './constants.js';
 import { wrapExpectedWithArray } from './util/elementsUtil.js';
-import { executeCommand } from './util/executeCommand.js';
-import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.js';
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const asymmetricMatcher = typeof Symbol === 'function' && Symbol.for
-    ? Symbol.for('jest.asymmetricMatcher')
-    : 0x13_57_a5;
+import { executeCommandWithStrategy } from './util/executeCommand.js';
+import { enhanceError, enhanceErrorBe } from './util/formatMessage.js';
+import { waitUntil } from './util/waitUntil.js';
+import { DEFAULT_FEATURE_FLAGS } from './constants.js';
+import { OneOfMatcher } from './matchers/asymmetrics/oneOf.js';
+export function isJasmineStringAsymmetricMatcher(expected) {
+    return isAsymmetricMatcher(expected) && !('toAsymmetricMatcher' in expected) && 'jasmineToString' in expected && typeof expected.jasmineToString === 'function';
+}
 export function isAsymmetricMatcher(expected) {
     return (typeof expected === 'object' &&
-        expected &&
-        '$$typeof' in expected &&
+        !!expected &&
         'asymmetricMatch' in expected &&
-        expected.$$typeof === asymmetricMatcher &&
-        Boolean(expected.asymmetricMatch));
+        !!expected.asymmetricMatch);
 }
-function isStringContainingMatcher(expected) {
-    return isAsymmetricMatcher(expected) && ['StringContaining', 'StringNotContaining'].includes(expected.toString());
+export function isStringContainingMatcherLike(expected) {
+    return !!expected && expected.constructor.name === 'StringContaining';
 }
-const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
-    if (wait === 0) {
-        return await condition();
-    }
-    let error;
-    try {
-        const start = Date.now();
-        while (true) {
-            if (Date.now() - start > wait) {
-                throw new Error('timeout');
-            }
-            try {
-                const result = isNot !== (await condition());
-                error = undefined;
-                if (result) {
-                    break;
-                }
-                await sleep(interval);
-            }
-            catch (err) {
-                error = err;
-                await sleep(interval);
-            }
-        }
-        if (error) {
-            throw error;
-        }
-        return !isNot;
+export function isInversedStringContainingMatcher(expected) {
+    return isStringContainingMatcherLike(expected) && expected.inverse === true;
+}
+export function getStringAsymmetricMatcherValue(expected) {
+    if ('expected' in expected) {
+        return expected.expected;
     }
-    catch {
-        if (error) {
-            throw error;
-        }
-        return isNot;
+    else if ('regexp' in expected) {
+        return expected.regexp;
     }
-};
-async function executeCommandBe(received, command, options) {
-    const { isNot, verb = 'be' } = this;
-    let el = await received?.getElement();
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, async (element) => ({ result: await command(element) }), options);
-        el = result.el;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceErrorBe(el, { ...this, verb }, options);
+    else if ('sample' in expected) {
+        return expected.sample;
+    }
+    throw new Error(`Could not extract value from asymmetric matcher: ${expected}. Please report this issue to the expect-webdriverio maintainers.`);
+}
+export function getAsymmetricMatcherValue(expected) {
+    if ('expected' in expected) {
+        return expected.expected;
+    }
+    else if ('expectedObject' in expected) {
+        return expected.expectedObject;
+    }
+    else if ('regexp' in expected) {
+        return expected.regexp;
+    }
+    else if ('sample' in expected) {
+        return expected.sample;
+    }
+    return undefined;
+}
+async function executeCommandBe(received, command, options = {}) {
+    const { isNot, verb = 'be', allowEmptyElements = false } = this;
+    const { success: pass, actual, subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: true,
+            singleElementCompare: async (element) => {
+                const result = await command(element);
+                return { success: result, actual: result };
+            },
+            context: { isNot, iteration },
+            strictConfiguration: { allowEmptyElements },
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceErrorBe(subject, actual, { ...this, verb, isSome }, options);
     return {
         pass,
         message: () => message,
@@ -84,11 +83,30 @@ const compareNumbers = (actual, options = {}) => {
     }
     return false;
 };
+export const compareTextOrArray = (actualText, expectedTexts, options) => {
+    if (expectedTexts === undefined) {
+        return { actual: actualText, success: false };
+    }
+    if (Array.isArray(expectedTexts)) {
+        if (expectedTexts.some((expected) => expected instanceof OneOfMatcher)) {
+            throw new Error('OneOf is not supported in array under legacy behavior. Please enable `useToHaveTextStrictMultiElementsCompareStrategy` feature flag to use the new strict index based matching strategy with `expect.oneOf()`.');
+        }
+        else {
+            console.warn('Array of expected values is deprecated. Please use `expect.oneOf()` asymmetric matcher to compare against multiple expected values. This will be removed in v8.0.0.');
+            expectedTexts = new OneOfMatcher(...expectedTexts).withOptions(options);
+        }
+    }
+    if (expectedTexts instanceof OneOfMatcher) {
+        return { success: expectedTexts.asymmetricMatch(actualText), actual: actualText };
+    }
+    const compareResults = compareText(actualText, expectedTexts, options);
+    return { success: compareResults.success, actual: actualText };
+};
 export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false, atStart = false, atEnd = false, atIndex, replace, }) => {
-    if (typeof actual !== 'string') {
+    if (typeof actual !== 'string' || expected === null || expected === undefined) {
         return {
-            value: actual,
-            result: false,
+            actual,
+            success: false,
         };
     }
     if (trim) {
@@ -102,59 +120,60 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
         if (typeof expected === 'string') {
             expected = expected.toLowerCase();
         }
-        else if (isStringContainingMatcher(expected)) {
-            expected = (expected.toString() === 'StringContaining'
-                ? expect.stringContaining(expected.sample?.toString().toLowerCase())
-                : expect.not.stringContaining(expected.sample?.toString().toLowerCase()));
+        else if (isStringContainingMatcherLike(expected)) {
+            const sample = getStringAsymmetricMatcherValue(expected).toString().toLocaleLowerCase();
+            expected = (isInversedStringContainingMatcher(expected)
+                ? expect.not.stringContaining(sample)
+                : expect.stringContaining(sample));
         }
     }
     if (isAsymmetricMatcher(expected)) {
         const result = expected.asymmetricMatch(actual);
         return {
-            value: actual,
-            result
+            actual,
+            success: result
         };
     }
     if (expected instanceof RegExp) {
         return {
-            value: actual,
-            result: !!actual.match(expected),
+            actual,
+            success: !!actual.match(expected),
         };
     }
     if (containing) {
         return {
-            value: actual,
-            result: actual.includes(expected),
+            actual,
+            success: actual.includes(expected),
         };
     }
     if (atStart) {
         return {
-            value: actual,
-            result: actual.startsWith(expected),
+            actual,
+            success: actual.startsWith(expected),
         };
     }
     if (atEnd) {
         return {
-            value: actual,
-            result: actual.endsWith(expected),
+            actual,
+            success: actual.endsWith(expected),
         };
     }
     if (atIndex) {
         return {
-            value: actual,
-            result: actual.substring(atIndex, actual.length).startsWith(expected),
+            actual,
+            success: actual.substring(atIndex, actual.length).startsWith(expected),
         };
     }
     return {
-        value: actual,
-        result: actual === expected,
+        actual,
+        success: actual === expected,
     };
 };
 export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false, trim = false, containing = false, atStart = false, atEnd = false, atIndex, replace, }) => {
     if (typeof actual !== 'string') {
         return {
-            value: actual,
-            result: false,
+            actual,
+            success: false,
         };
     }
     if (trim) {
@@ -169,15 +188,16 @@ export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false
             if (typeof item === 'string') {
                 return item.toLowerCase();
             }
-            if (isStringContainingMatcher(item)) {
-                return (item.toString() === 'StringContaining'
-                    ? expect.stringContaining(item.sample?.toString().toLowerCase())
-                    : expect.not.stringContaining(item.sample?.toString().toLowerCase()));
+            if (isStringContainingMatcherLike(item)) {
+                const sample = getStringAsymmetricMatcherValue(item).toString().toLocaleLowerCase();
+                return (isInversedStringContainingMatcher(item)
+                    ? expect.not.stringContaining(sample)
+                    : expect.stringContaining(sample));
             }
             return item;
         });
     }
-    const textInArray = expectedArray.some((expected) => {
+    const hasFoundTextInArray = expectedArray.some((expected) => {
         if (expected instanceof RegExp) {
             return !!actual.match(expected);
         }
@@ -199,24 +219,24 @@ export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false
         return actual === expected;
     });
     return {
-        value: actual,
-        result: textInArray,
+        actual,
+        success: hasFoundTextInArray,
     };
 };
 export const compareObject = (actual, expected) => {
     if (typeof actual !== 'object' || Array.isArray(actual)) {
         return {
-            value: actual,
-            result: false,
+            actual,
+            success: false,
         };
     }
     return {
-        value: actual,
-        result: deepEql(actual, expected),
+        actual,
+        success: deepEql(actual, expected),
     };
 };
 export const compareStyle = async (actualEl, style, { ignoreCase = false, trim = true, containing = false, atStart = false, atEnd = false, atIndex, replace, }) => {
-    let result = true;
+    let success = true;
     const actual = {};
     for (const key in style) {
         const css = await actualEl.getCSSProperty(key);
@@ -231,42 +251,37 @@ export const compareStyle = async (actualEl, style, { ignoreCase = false, trim =
             expectedVal = expectedVal.toLowerCase();
         }
         if (containing) {
-            result = actualVal.includes(expectedVal);
+            success = actualVal.includes(expectedVal);
             actual[key] = actualVal;
         }
         else if (atStart) {
-            result = actualVal.startsWith(expectedVal);
+            success = actualVal.startsWith(expectedVal);
             actual[key] = actualVal;
         }
         else if (atEnd) {
-            result = actualVal.endsWith(expectedVal);
+            success = actualVal.endsWith(expectedVal);
             actual[key] = actualVal;
         }
         else if (atIndex) {
-            result = actualVal.substring(atIndex, actualVal.length).startsWith(expectedVal);
+            success = actualVal.substring(atIndex, actualVal.length).startsWith(expectedVal);
             actual[key] = actualVal;
         }
         else if (replace) {
             const replacedActual = replaceActual(replace, actualVal);
-            result = replacedActual === expectedVal;
+            success = replacedActual === expectedVal;
             actual[key] = replacedActual;
         }
         else {
-            result = result && actualVal === expectedVal;
+            success = success && actualVal === expectedVal;
             actual[key] = css.value;
         }
     }
     return {
-        value: actual,
-        result,
+        actual,
+        success,
     };
 };
-function aliasFn(fn, { verb, expectation, } = {}, ...args) {
-    this.verb = verb;
-    this.expectation = expectation;
-    return fn.apply(this, args);
-}
-export { aliasFn, compareNumbers, enhanceError, executeCommand, executeCommandBe, numberError, waitUntil, wrapExpectedWithArray };
+export { compareNumbers, enhanceError, executeCommandBe, waitUntil, wrapExpectedWithArray };
 function replaceActual(replace, actual) {
     const hasMultipleReplacers = replace.every((r) => Array.isArray(r));
     const replacers = hasMultipleReplacers
@@ -281,3 +296,11 @@ function replaceActual(replace, actual) {
     }
     return actual;
 }
+export const getFeatureFlagValue = ({ featureFlags }, featureFlag) => {
+    const providedFeatureFlagValue = featureFlags?.[featureFlag];
+    if (providedFeatureFlagValue !== undefined) {
+        return providedFeatureFlagValue;
+    }
+    return DEFAULT_FEATURE_FLAGS[featureFlag] ?? false;
+};
+export const toArray = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "5.6.9",
+  "version": "6.0.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -77,29 +77,31 @@
     "playgrounds:snapshots:update": "cd playgrounds && npm run snapshots:update"
   },
   "dependencies": {
-    "@vitest/snapshot": "^4.1.7",
+    "@vitest/snapshot": "^4.1.10",
     "deep-eql": "^5.0.2",
     "expect": "^30.4.1",
     "jest-matcher-utils": "^30.4.1"
   },
   "devDependencies": {
+    "@jest/globals": "^30.4.1",
     "@types/debug": "^4.1.13",
     "@types/jasmine": "^5.1.15",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.12.4",
     "@types/mocha": "^10.0.10",
-    "@jest/globals": "^30.4.1",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@types/node": "^24.13.3",
+    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/eslint-plugin": "^1.6.26",
     "@wdio/eslint": "^0.1.3",
-    "@wdio/types": "^9.27.2",
-    "eslint": "^9.39.4",
+    "@wdio/types": "^9.30.1",
+    "eslint": "^9.39.5",
     "husky": "^9.1.7",
-    "npm-run-all2": "^9.0.1",
-    "release-it": "^20.2.0",
+    "npm-run-all2": "^9.0.3",
+    "release-it": "^20.2.1",
     "rimraf": "^6.1.3",
+    "strip-ansi": "^7.2.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.7",
-    "webdriverio": "^9.27.2"
+    "vitest": "^4.1.10",
+    "webdriverio": "^9.30.1"
   },
   "peerDependencies": {
     "@wdio/globals": "^9.0.0",

package/types/expect-global.d.ts

@@ -5,11 +5,12 @@
  * Required when used in standalone mode (mocha) or to override the one of Jasmine
  */
 
-//// @ts-expect-error: IDE might flags this one but just does be concerned by it. This way the `tsc:root-types` can pass!
+// @ts-expect-error: IDE might flags this one but just does be concerned by it. This way the `tsc:root-types` can pass!
 declare const expect: ExpectWebdriverIO.Expect
 
 declare namespace NodeJS {
     interface Global {
+        // @ts-expect-error: Both wdio & Jasmine augmentation declare different global expect explaining why TS is complaining here
         expect: ExpectWebdriverIO.Expect
     }
 }