expect-webdriverio 7.0.0 → 8.0.0-alpha.0

package/lib/util/multiRemoteUtils.js

@@ -73,12 +73,20 @@ export const getMockInstanceNames = (mocks) => {
 };
 export const isGlobalBrowserSingleRemote = () => {
     try {
-        return typeof browser !== 'undefined' && isBrowser(browser) && !browser.isMultiremote;
+        return typeof browser !== 'undefined' && isBrowser(browser) && !hasMultiRemoteFlag(browser);
     }
     catch {
         return false;
     }
 };
+export const hasMultiRemoteFlag = (obj) => {
+    if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+        return false;
+    }
+    const { isMultiRemote, isMultiremote } = obj;
+    return isMultiRemote === true || isMultiremote === true;
+};
+export const isMultiRemoteBrowser = (browser) => hasMultiRemoteFlag(browser);
 export const isBrowser = (obj) => {
     const name = obj?.constructor?.name?.replace(/^bound /, '');
     return name === 'Browser' || !!name?.endsWith('MultiRemoteDriver');

package/lib/util/numberOptionsUtil.js

@@ -1,41 +1,37 @@
 import { AsymmetricMatcher } from 'expect';
-import { isDefinedPlainObject } from './commandOptionsUtils.js';
 import { isMultiRemoteMatcher } from './multiRemoteUtils.js';
 export const isNumber = (value) => typeof value === 'number' && !isNaN(value);
 export const isDefinedNotNumber = (value) => value !== undefined && !isNumber(value);
 export const isDefinedNumberOrNonEmptyObject = (value) => typeof value === 'number' || (typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0);
-export function validateNumberAndExtractOptions(expectedValue, commandOptions, { supportDefaultAsGteThen1 } = {}) {
-    let defaultExpectedValue = undefined;
-    if (supportDefaultAsGteThen1 && (expectedValue === undefined || (isDefinedPlainObject(expectedValue) && expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined))) {
-        defaultExpectedValue = new NumberMatcher({ gte: 1 });
+const NUMBER_MATCHER_KEYS = ['eq', 'gte', 'lte'];
+export function validateNumberMatcher(expectedValue, { supportDefaultAsGteThen1 } = {}) {
+    if (supportDefaultAsGteThen1 && expectedValue === undefined) {
+        return new NumberMatcher({ gte: 1 });
     }
-    else if (isNumber(expectedValue)) {
-        return { numberMatcher: new NumberMatcher({ eq: expectedValue }), commandOptions };
+    if (isNumber(expectedValue)) {
+        return new NumberMatcher({ eq: expectedValue });
     }
-    else if (!isDefinedNumberOrNonEmptyObject(expectedValue) || isDefinedNotNumber(expectedValue.eq) || isDefinedNotNumber(expectedValue.gte) || isDefinedNotNumber(expectedValue.lte)
+    if (!isDefinedNumberOrNonEmptyObject(expectedValue)
+        || Object.keys(expectedValue).some((key) => !NUMBER_MATCHER_KEYS.includes(key))
+        || isDefinedNotNumber(expectedValue.eq) || isDefinedNotNumber(expectedValue.gte) || isDefinedNotNumber(expectedValue.lte)
         || (expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined)) {
         throw new Error(`Invalid NumberMatcher. Received: ${JSON.stringify(expectedValue)}`);
     }
-    const { eq, gte, lte, ...restCommandOptions } = expectedValue ?? {};
+    const { eq, gte, lte } = expectedValue;
     if (isNumber(gte) && isNumber(lte) && gte > lte) {
         throw new Error(`Invalid NumberMatcher range: 'gte' (${gte}) cannot be greater than 'lte' (${lte}).`);
     }
-    return {
-        numberMatcher: defaultExpectedValue ?? new NumberMatcher({ eq, gte, lte }),
-        commandOptions: { ...commandOptions, ...restCommandOptions }
-    };
+    return new NumberMatcher({ eq, gte, lte });
 }
-export function validateNumberArrayAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 } = {}) {
+export function validateNumberMatcherArray(expectedValues, { supportDefaultAsGteThen1 } = {}) {
     if (isMultiRemoteMatcher(expectedValues)) {
         const perInstanceValues = expectedValues.sample;
-        const numberMatcher = Object.fromEntries(Object.entries(perInstanceValues).map(([instance, value]) => [instance, validateNumberArrayAndExtractOptions(value, commandOptions).numberMatcher]));
-        return { numberMatcher, commandOptions };
+        return Object.fromEntries(Object.entries(perInstanceValues).map(([instance, value]) => [instance, validateNumberMatcherArray(value)]));
     }
     if (Array.isArray(expectedValues)) {
-        const allNumbers = expectedValues.map((value) => validateNumberAndExtractOptions(value, commandOptions, { supportDefaultAsGteThen1 }));
-        return { numberMatcher: allNumbers.map(({ numberMatcher }) => numberMatcher), commandOptions };
+        return expectedValues.map((value) => validateNumberMatcher(value, { supportDefaultAsGteThen1 }));
     }
-    return validateNumberAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 });
+    return validateNumberMatcher(expectedValues, { supportDefaultAsGteThen1 });
 }
 export class NumberMatcher extends AsymmetricMatcher {
     sample;
@@ -89,10 +85,3 @@ export class NumberMatcher extends AsymmetricMatcher {
         return this.toString();
     }
 }
-export const isEmptyOrLegacyNumberOptions = (value) => {
-    if (!isDefinedPlainObject(value)) {
-        return false;
-    }
-    const keys = Object.keys(value);
-    return keys.length === 0 || keys.filter((key) => !['eq', 'gte', 'lte'].includes(key)).length > 0;
-};

package/lib/utils.js

@@ -4,8 +4,7 @@ import { wrapExpectedWithArray } from './util/elementsUtil.js';
 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 { isOneOfMatcher, OneOfMatcher } from './matchers/asymmetrics/oneOf.js';
+import { isOneOfMatcher } from './matchers/asymmetrics/oneOf.js';
 export function isJasmineStringAsymmetricMatcher(expected) {
     return isAsymmetricMatcher(expected) && !('toAsymmetricMatcher' in expected) && 'jasmineToString' in expected && typeof expected.jasmineToString === 'function';
 }
@@ -68,8 +67,8 @@ export function getAsymmetricMatcherValue(expected) {
     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) => {
+    const { isNot, verb = 'be', expectation = '', allowEmptyElements = false } = this;
+    const { success: pass, actual, subject, context: { isSome = false } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: true,
@@ -81,44 +80,20 @@ async function executeCommandBe(received, command, options = {}) {
             strictConfiguration: { allowEmptyElements },
         });
     }, isNot, { wait: options.wait, interval: options.interval });
-    const message = enhanceErrorBe(subject, actual, { ...this, verb, isSome }, options);
+    const message = enhanceErrorBe(subject, actual, { ...this, verb, expectation, isSome }, options);
     return {
         pass,
         message: () => message,
     };
 }
-const compareNumbers = (actual, options = {}) => {
-    if (typeof options.eq === 'number') {
-        return actual === options.eq;
-    }
-    if (typeof options.gte === 'number' && typeof options.lte === 'number') {
-        return actual >= options.gte && actual <= options.lte;
-    }
-    if (typeof options.gte === 'number') {
-        return actual >= options.gte;
-    }
-    if (typeof options.lte === 'number') {
-        return actual <= options.lte;
-    }
-    return false;
-};
-export const compareTextOrOneOf = (actualText, expectedTexts, options) => {
-    if (expectedTexts === undefined) {
+export const compareTextOrOneOf = (actualText, expectedText, options) => {
+    if (expectedText === undefined || Array.isArray(expectedText)) {
         return { actual: actualText, success: false };
     }
-    if (Array.isArray(expectedTexts)) {
-        if (expectedTexts.some((expected) => isOneOfMatcher(expected))) {
-            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 (isOneOfMatcher(expectedTexts)) {
-        return { success: expectedTexts.asymmetricMatch(actualText), actual: actualText };
+    if (isOneOfMatcher(expectedText)) {
+        return { success: expectedText.asymmetricMatch(actualText), actual: actualText };
     }
-    const compareResults = compareText(actualText, expectedTexts, options);
+    const compareResults = compareText(actualText, expectedText, options);
     return { ...compareResults, actual: actualText };
 };
 export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false, atStart = false, atEnd = false, atIndex, replace, }) => {
@@ -202,74 +177,6 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
         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 {
-            actual,
-            success: false,
-        };
-    }
-    if (trim) {
-        actual = actual.trim();
-    }
-    if (Array.isArray(replace)) {
-        actual = replaceActual(replace, actual);
-    }
-    const actualOriginalCase = actual;
-    if (ignoreCase) {
-        actual = actual.toLowerCase();
-        expectedArray = expectedArray.map((item) => {
-            if (typeof item === 'string') {
-                return item.toLowerCase();
-            }
-            if (item instanceof RegExp) {
-                return withIgnoreCaseFlag(item);
-            }
-            if (isStringContainingMatcherLike(item)) {
-                const sample = getStringAsymmetricMatcherValue(item).toString().toLocaleLowerCase();
-                return (isInversedStringContainingMatcher(item)
-                    ? expect.not.stringContaining(sample)
-                    : expect.stringContaining(sample));
-            }
-            if (isStringMatchingMatcherLike(item)) {
-                const sample = getStringAsymmetricMatcherValue(item);
-                const caseInsensitiveSample = withIgnoreCaseFlag(sample instanceof RegExp ? sample : new RegExp(sample));
-                return (isInversedStringMatchingMatcher(item)
-                    ? expect.not.stringMatching(caseInsensitiveSample)
-                    : expect.stringMatching(caseInsensitiveSample));
-            }
-            return item;
-        });
-    }
-    const hasFoundTextInArray = expectedArray.some((expected) => {
-        if (expected instanceof RegExp) {
-            return !!actualOriginalCase.match(expected);
-        }
-        if (isStringMatchingMatcherLike(expected) && getStringAsymmetricMatcherValue(expected) instanceof RegExp) {
-            return expected.asymmetricMatch(actualOriginalCase);
-        }
-        if (isAsymmetricMatcher(expected)) {
-            return expected.asymmetricMatch(actual);
-        }
-        if (containing) {
-            return actual.includes(expected);
-        }
-        if (atStart) {
-            return actual.startsWith(expected);
-        }
-        if (atEnd) {
-            return actual.endsWith(expected);
-        }
-        if (atIndex !== undefined) {
-            return actual.substring(atIndex, actual.length).startsWith(expected);
-        }
-        return actual === expected;
-    });
-    return {
-        actual: actualOriginalCase,
-        success: hasFoundTextInArray,
-    };
-};
 export const compareObject = (actual, expected) => {
     if (typeof actual !== 'object' || Array.isArray(actual)) {
         return {
@@ -335,7 +242,7 @@ export const compareStyle = async (actualEl, style, { ignoreCase = false, trim =
         success,
     };
 };
-export { compareNumbers, enhanceError, executeCommandBe, waitUntil, wrapExpectedWithArray };
+export { enhanceError, executeCommandBe, waitUntil, wrapExpectedWithArray };
 function withIgnoreCaseFlag(expected) {
     const cloned = expected.ignoreCase
         ? new RegExp(expected.source, expected.flags)
@@ -357,11 +264,4 @@ 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": "7.0.0",
+  "version": "8.0.0-alpha.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -19,7 +19,7 @@
     "wdio"
   ],
   "type": "module",
-  "module": "./lib/index.js",
+  "main": "./lib/index.js",
   "exports": {
     ".": [
       {
@@ -43,7 +43,6 @@
         "types": "./jasmine-wdio-expect-async.d.ts"
       }
     ],
-    "./types": "./types/expect-global.d.ts",
     "./expect-global": "./types/expect-global.d.ts",
     "./api": [
       {
@@ -56,8 +55,9 @@
   "types": "./types/expect-webdriverio.d.ts",
   "typeScriptVersion": "3.8.3",
   "engines": {
-    "node": ">=20"
+    "node": ">=22.19.0"
   },
+  "packageManager": "pnpm@11.27.1+sha512.a81d4c21b9b09a4b0aebf90ef5e527d4262bdda322d26082978cb549023ac6d9cafc98b19fffaa5c71db438a65f70224edb78d7311187861ff96480d1cdca23c",
   "scripts": {
     "build": "run-s clean compile",
     "clean": "run-p clean:*",
@@ -65,66 +65,63 @@
     "compile": "run-s compile:*",
     "compile:lib": "tsc --build tsconfig.build.json",
     "compile:check": "if [ ! -f lib/index.js ] || [ $(find lib -type f | wc -l) -le 30 ]; then echo 'File structure under lib is broken'; exit 1; fi",
-    "tsc:root-types": "node types-checks-filter-out-node_modules.js",
     "test": "run-s test:*",
     "test:tsc": "tsc --project tsconfig.json --noEmit --rootDir .",
-    "test:lint": "eslint .",
+    "test:lint": "oxlint",
     "test:unit": "vitest --run",
-    "test:types": "npm run ts && npm run tsc:root-types",
+    "test:types": "pnpm run ts",
     "ts": "run-s ts:* ts:*:*",
-    "ts:jasmine": "cd test-types/jasmine && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
-    "ts:jasmine-global-expect-async": "cd test-types/jasmine-global-expect-async && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
-    "ts:jest:@types-jest": "cd test-types/jest-@types_jest && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
-    "ts:mocha": "cd test-types/mocha && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
-    "ts:arethetypeswrong": "npx @arethetypeswrong/cli --pack . --profile esm-only",
-    "checks:all": "npm run build && npm run compile && npm run tsc:root-types && npm run test && npm run ts",
-    "watch": "npm run compile -- --watch",
+    "ts:jasmine": "cd test-types/jasmine && vitest --typecheck --coverage.enabled=false --typecheck.tsconfig ./tsconfig.json --run",
+    "ts:jasmine-global-expect-async": "cd test-types/jasmine-global-expect-async && vitest --typecheck --coverage.enabled=false --typecheck.tsconfig ./tsconfig.json --run",
+    "ts:jest:@types-jest": "cd test-types/jest-@types_jest && vitest --typecheck --coverage.enabled=false --typecheck.tsconfig ./tsconfig.json --run",
+    "ts:mocha": "cd test-types/mocha && vitest --typecheck --coverage.enabled=false --typecheck.tsconfig ./tsconfig.json --run",
+    "ts:arethetypeswrong": "attw --pack . --profile esm-only",
+    "ts:declarations": "node types-checks-declarations.js",
+    "ts:package": "node types-checks-package.js",
+    "checks:all": "pnpm run build && pnpm test",
+    "watch": "pnpm run compile --watch",
     "prepare": "husky",
     "playgrounds:clean": "rimraf --glob '**/node_modules'",
-    "playgrounds:setup": "npm run playgrounds:clean; npm i && cd playgrounds && npm run setup",
-    "playgrounds:checks:all": "cd playgrounds && npm run checks:all",
-    "playgrounds:snapshots:update": "cd playgrounds && npm run snapshots:update"
+    "playgrounds:setup": "pnpm run playgrounds:clean; pnpm install && cd playgrounds && pnpm run setup",
+    "playgrounds:checks:all": "cd playgrounds && pnpm run checks:all",
+    "playgrounds:snapshots:update": "cd playgrounds && pnpm run snapshots:update"
   },
   "dependencies": {
-    "@vitest/snapshot": "^4.1.11",
+    "@vitest/snapshot": "^5.0.2",
+    "@wdio/types": "^9.31.5",
     "deep-eql": "^5.0.2",
-    "expect": "^30.4.1",
-    "jest-matcher-utils": "^30.4.1"
+    "expect": "^30.5.2",
+    "jest-matcher-utils": "^30.5.2"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@jest/globals": "^30.4.1",
+    "@jest/globals": "^30.5.2",
+    "@stylistic/eslint-plugin": "^5.10.0",
     "@types/debug": "^4.1.13",
-    "@types/jasmine": "^5.1.15",
+    "@types/deep-eql": "^4.0.2",
+    "@types/jasmine": "^6.0.0",
     "@types/jest": "^30.0.0",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.13.3",
-    "@vitest/coverage-v8": "^4.1.11",
-    "@vitest/eslint-plugin": "^1.6.27",
-    "@wdio/eslint": "^0.1.3",
-    "@wdio/types": "^9.32.0",
-    "eslint": "^9.39.5",
+    "@types/node": "^24.19.0",
+    "@vitest/coverage-v8": "^5.0.2",
+    "@wdio/cli": "^9.32.0",
+    "@wdio/globals": "^9.31.3",
+    "@wdio/protocols": "^9.31.5",
     "husky": "^9.1.7",
     "npm-run-all2": "^9.0.3",
-    "release-it": "^21.0.2",
+    "oxlint": "^1.85.0",
+    "release-it": "^21.1.0",
     "rimraf": "^6.1.3",
     "strip-ansi": "^7.2.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.11",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2",
+    "webdriver": "^9.32.0",
     "webdriverio": "^9.32.0"
   },
   "peerDependencies": {
-    "@wdio/globals": "^9.23.0",
-    "@wdio/logger": "^9.0.0",
     "webdriverio": "^9.31.5"
   },
   "peerDependenciesMeta": {
-    "@wdio/globals": {
-      "optional": false
-    },
-    "@wdio/logger": {
-      "optional": false
-    },
     "webdriverio": {
       "optional": false
     }

package/types/expect-global.d.ts

@@ -5,12 +5,11 @@
  * 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-ignore, not @ts-expect-error: only a conflict when the Jasmine `expect` is also loaded
 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
     }
 }