expect-webdriverio 0.1.1-beta.5 → 1.0.0

package/README.md

@@ -1,14 +1,17 @@
 # expect-webdriverio
 
+[![Build Status](https://travis-ci.org/webdriverio/expect-webdriverio.svg?branch=master)](https://travis-ci.org/webdriverio/expect-webdriverio) [![codecov](https://codecov.io/gh/webdriverio/expect-webdriverio/branch/master/graph/badge.svg)](https://codecov.io/gh/webdriverio/expect-webdriverio)
+
+###### [TypeScript / JS Autocomplete](/docs/Types.md) | [Examples](docs/Examples.md) | [Extending Matchers](/docs/Extend.md)
+
 > [WebdriverIO](https://webdriver.io/) Assertion library inspired by [expect](https://www.npmjs.com/package/expect)
 
 ## Key Features
 
-- automatically waits for expectation to succeed
-- see full element selector in error
-- add your own messages
+- [waits](#default-options) for expectation to succeed
+- detailed [error messages](#error-messages)
 - works in Mocha, Cucumber, Jest, Jasmine
-- builtin types for TypeScript and JS autocompletion
+- builtin [types](docs/Types.md) for TypeScript and JS autocompletion
 
 ## Installation
 
@@ -22,84 +25,26 @@ NOTE: [WebdriverIO](https://github.com/webdriverio/webdriverio) `v5.16.11` or hi
 In your `wdio.conf.js`
 ```js
 beforeSession () { // before hook works as well
-    // with default options
     require('expect-webdriverio')
-    // If you like to override default options
-    // require('expect-webdriverio').setOptions({ wait: 9000 })
 },
 ```
 
 In your test
 ```js
-describe('suite', () => {
-    before(() => {
-        browser.url('https://github.com/mgrybyk/expect-webdriverio')
-        
-        expect(browser).toHaveUrl('https://github.com/mgrybyk/expect-webdriverio')
-        expect(browser).toHaveTitle('expect-webdriverio', { containing: true })
-    })
-
-    it('be visible', () => {
-        const notVisible = $('body').$$('div')[2].$("not-visible")
-        
-        // wait for 2000ms for expectation to succeed by default
-        expect(notVisible).toExist()
-
-        // override default wait timeout        
-        expect(notVisible).toBeVisible({ wait: 0 })
-        // fails with error
-        // Element "$(`body`).$$(`div`)[2].$(`not-visible`)" is not displayed.
-    })
-
-    it('find elements', () => {
-        const formInputs = $$('form input')
-
-        // make sure every form element is enabled
-        // waits automatically for formInputs to have at least one element
-        expect(formInputs).toBeEnabled({ wait: 5000 })
-
-        const selectOptions = $$('form select>option')
-
-        // make sure there is at least one option in select
-        expect(selectOptions).toBeElementsArrayOfSize({ gte: 1 })
-        // exact match
-        expect($$('button')).toBeElementsArrayOfSize(3)
-    })
-
-    it('advanced', () => {
-        const myInput = $('input')
-
-        expect(myInput).toHaveClass('form-control', { message: 'Not a form control!', })
-        expect(myInput).toHaveAttribute('class', 'form-control') // alias toHaveAttr
-        
-        expect(myInput).toHaveValueContaining('USER')
-        // or pass `containing` as an option
-        expect(myInput).toHaveValue('value', 'user', { containing: true, ignoreCase: true })
-
-        // Simply invert assertions
-        expect(myInput).not.toHaveProperty('height', 0)
-    })
-
-    it('async mode', async () => {
-        const el = await $('el')
-        await expect(el).toBePresent() // aliases toBeExisting or toExist
-
-        // or
-        await expect($('el')).toBePresent()
-    })
-})
-``` 
+const $button = $('button')
+expect($button).toBeDisplayed()
+```
+
+See more [Examples](docs/Examples.md)
 
 ## API
 
-See available [Matchers](https://github.com/mgrybyk/expect-webdriverio/blob/master/types/expect-webdriverio.d.ts#L64)
+See available [Matchers](https://github.com/webdriverio/expect-webdriverio/blob/master/types/expect-webdriverio.d.ts#L64)
 
-Besides of `expect-webdriverio` assertions you can use builtin [expect assertions](https://jestjs.io/docs/en/expect).
+Besides of the `expect-webdriverio` matchers you can use builtin Jest's [expect](https://jestjs.io/docs/en/expect) assertions or [expect/expectAsync](https://jasmine.github.io/api/3.5/global.html#expect) for Jasmine.
 
 ## Default Options
 
-Options will be extended soon to provide more flexibility!
-
 ```js
 {
     wait: 2000, // ms to wait for expectation to succeed
@@ -107,44 +52,444 @@ Options will be extended soon to provide more flexibility!
 }
 ```
 
-## TypeScript
+Set options like this:
+```js
+beforeSession () { // before hook works as well
+    require('expect-webdriverio').setOptions({ wait: 5000 })
+},
+```
+
+### Matcher Options
+
+Every matcher can take several options that allows you to modify the assertion:
+
+##### Command Options
+
+| Name | Type | Details |
+| ---- | ---- | ------- |
+| <code><var>wait</var></code> | number | time in ms to wait for expectation to succeed. Default: `3000` |
+| <code><var>interval</var></code> | number | interval between attempts. Default: `100` |
+| <code><var>message</var></code> | string | user message to prepend before assertion error |
+
+##### String Options
+
+This options can be applied in addition to the command options when strings are being asserted.
+
+| Name | Type | Details |
+| ---- | ---- | ------- |
+| <code><var>ignoreCase</var></code> | boolean | apply `toLowerCase` to both actual and expected values |
+| <code><var>trim</var></code> | boolean | apply `trim` to actual value |
+| <code><var>containing</var></code> | boolean | expect actual value to contain expected value, otherwise strict equal. |
+| <code><var>asString</var></code> | boolean | might be helpful to force converting property value to string |
+
+##### Number Options
+
+This options can be applied in addition to the command options when numbers are being asserted.
+
+| Name | Type | Details |
+| ---- | ---- | ------- |
+| <code><var>eq</var></code> | number | equals |
+| <code><var>lte</var></code> | number | less then equals |
+| <code><var>gte</var></code> | number | greater than or equals |
+
+## Browser Matchers
+
+### toHaveUrl
+
+Checks if browser is on a specifc page.
+
+##### Usage
+
+```js
+browser.url('https://webdriver.io/')
+expect(browser).toHaveUrl('https://webdriver.io')
+```
+
+### toHaveTitle
+
+Checks if website has a specific title.
+
+##### Usage
+
+```js
+browser.url('https://webdriver.io/')
+expect(browser).toHaveTitle('WebdriverIO · Next-gen WebDriver test framework for Node.js')
+```
+
+## Element Matchers
+
+### toBeDisplayed
+
+Calls [`isDisplayed`](/docs/api/element/isDisplayed.html) on given element.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toBeDisplayed()
+```
+
+### toBeVisible
+
+Same as `toBeDisplayed`.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toBeVisible()
+```
+
+### toExist
+
+Calls [`isExisting`](/docs/api/element/isExisting.html) on given element.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toExist()
+```
+
+### toBePresent
+
+Same as `toExist`.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toBePresent()
+```
+
+### toBeExisting
+
+Same as `toExist`.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toBeExisting()
+```
+
+### toBeFocused
+
+Checks if element has focus. This assertion only works in a web context.
+
+##### Usage
+
+```js
+const elem = $('#someElem')
+expect(elem).toBeFocused()
+```
+
+### toHaveAttribute
+
+Checks if an element has a certain attribute with a specific value.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveAttribute('class', 'form-control')
+```
+
+### toHaveAttr
+
+Same as `toHaveAttribute`.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveAttr('class', 'form-control')
+```
+
+### toHaveAttributeContaining
+
+Checks if an element has a certain attribute that contains a value.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveAttributeContaining('class', 'form')
+```
+
+### toHaveAttrContaining
+
+Same as `toHaveAttributeContaining`.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveAttrContaining('class', 'form')
+```
+
+### toHaveClass
+
+Checks if an element has a certain class name.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveClass('form-control', { message: 'Not a form control!', })
+```
+
+### toHaveClassContaining
+
+Checks if an element has a certain class name that contains provided value.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveClassContaining('form')
+```
+
+### toHaveProperty
+
+Checks if an element has a certain property.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toHaveProperty('height', 23)
+expect(elem).not.toHaveProperty('height', 0)
+```
+
+### toHaveValue
 
-Add expect-webdriverio to `types` in the `tsconfig.json`
-- `"expect-webdriverio"` for everyone except of Jasmine/Jest users.
-- `"expect-webdriverio/jasmine"` Jasmine
-- `"expect-webdriverio/jest"` Jest
+Checks if an input element has a certain value.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveValue('user', { ignoreCase: true })
+```
+
+### toHaveValueContaining
+
+Checks if an input element contains a certain value.
+
+##### Usage
+
+```js
+const myInput = $('input')
+expect(myInput).toHaveValue('us')
+```
+
+### toBeClickable
+
+Checks if an element can be clicked by calling [`isClickable`](/docs/api/element/isClickable.html) on the element.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeClickable()
+```
+
+### toBeDisabled
+
+Checks if an element is disabled by calling [`isEnabled`](/docs/api/element/isEnabled.html) on the element.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeDisabled()
+// same as
+expect(elem).not.toBeEnabled()
+```
+
+### toBeEnabled
+
+Checks if an element is enabled by calling [`isEnabled`](/docs/api/element/isEnabled.html) on the element.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeEnabled()
+// same as
+expect(elem).not.toBeDisabled()
+```
+
+### toBeSelected
+
+Checks if an element is enabled by calling [`isSelected`](/docs/api/element/isSelected.html) on the element.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeSelected()
+```
+
+### toBeChecked
+
+Same as `toBeSelected`.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeChecked()
+```
+
+### toHaveHref
+
+Checks if link element has a specifc link target.
+
+##### Usage
+
+```js
+const link = $('a')
+expect(link).toHaveHref('https://webdriver.io')
+```
+
+### toHaveLink
+
+Same as `toHaveHref`.
+
+##### Usage
+
+```js
+const link = $('a')
+expect(link).toHaveLink('https://webdriver.io')
+```
+
+### toHaveHrefContaining
+
+Checks if link element contains a specifc link target.
+
+##### Usage
+
+```js
+const link = $('a')
+expect(link).toHaveHrefContaining('webdriver.io')
+```
+
+### toHaveLinkContaining
+
+Same as `toHaveHrefContaining`.
+
+##### Usage
+
+```js
+const link = $('a')
+expect(link).toHaveLinkContaining('webdriver.io')
+```
+
+### toHaveId
+
+Checks if element has a specific `id` attribute.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toHaveId('elem')
+```
+
+### toHaveText
+
+Checks if element has a specific text.
+
+##### Usage
+
+```js
+browser.url('https://webdriver.io/')
+const elem = $('.tagline')
+expect(elem).toHaveText('Next-gen WebDriver test framework for Node.js')
+```
+
+### toHaveTextContaining
+
+Checks if element contains a specific text.
+
+##### Usage
+
+```js
+browser.url('https://webdriver.io/')
+const elem = $('.tagline')
+expect(elem).toHaveTextContaining('WebDriver test framework')
+```
+
+### toBeDisplayedInViewport
+
+Checks if an element is within the viewport by calling [`isDisplayedInViewport`](/docs/api/element/isDisplayedInViewport.html) on the element.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeDisplayedInViewport()
+```
+
+### toBeVisibleInViewport
+
+Same as `toBeDisplayedInViewport`.
+
+##### Usage
+
+```js
+const elem = $('#elem')
+expect(elem).toBeVisibleInViewport()
+```
+
+### toHaveChildren
+
+Checks amount of fetched elements using [`$$`](/docs/api/browser/$$.html) command.
+
+##### Usage
+
+```js
+const elems = $$('div')
+expect(elems).toHaveChildren({ gte: 10 })
+// same as
+assert.ok(elems.length >= 10)
+```
+
+### toBeElementsArrayOfSize
+
+Same as `toHaveChildren`.
+
+##### Usage
+
+```js
+const elems = $$('div')
+expect(elems).toBeElementsArrayOfSize({ gte: 10 })
+// same as
+assert.ok(elems.length >= 10)
+```
 
 ## Error messages
 
 Error messages are informative out of the box and contain:
 
-- full element selector
-- property type to be verified
+- full element selector, like `$('form').$('input')`
 - actual and expected values
 - highlight the difference (texts assertions)
 
-#### Examples
-![toHaveClass](/docs/img/errors/toHaveClass.png?raw=true "toHaveClass")
+![toHaveText](/docs/img/errors/text.png?raw=true "toHaveText")
+![toHaveClass](/docs/img/errors/class.png?raw=true "toHaveClass")
+![not.toBeVisible](/docs/img/errors/not-visible.png?raw=true "not.toBeVisible")
 
 ## What's next?
 
 First of all, **feel free to raise an issue with your suggestions or help with PR!**
 
-New features and improvements, of course!
-
-### Almost there
-
-- boilerplate projects
-
-### Coming soon...
-
-- css
-- size
-- cookie / localStorage ?
-- docs
-
-### Also planned
+### Planned
 
-- more matchers
-- advanced matchers with regex
+- css matcher
+- size matcher
+- cookie / localStorage matchers?
+- text regex matchers
 - multiremote support (if requested)

package/jasmine.d.ts

@@ -2,4 +2,5 @@
 
 declare module jasmine {
     interface Matchers<T> extends ExpectWebdriverIO.Matchers {}
+    interface AsyncMatchers<T, U> extends ExpectWebdriverIO.Matchers {}
 }

package/lib/addMatchers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let expectLib;
+exports.addMatchers = () => {
+    if (global.expect === undefined) {
+        if (!exports.loadExpect()) {
+            return;
+        }
+        global.expect = expectLib;
+    }
+    else {
+        expectLib = global.expect;
+    }
+    if (!global.expect.extend && !exports.isJasmine()) {
+        if (!exports.loadExpect()) {
+            return;
+        }
+        global.expectWdio = expectLib;
+        console.warn('Warning! Unsupported expect lib is used.\n' +
+            "Only Jasmine >= 3.3.0 and Jest's expect are supported.\n" +
+            "expect-webdriverio is assigned to global.expectWdio");
+    }
+    require('./options').setDefaultOptions;
+    const matchers = require('./matchers').default;
+    if (expectLib.extend) {
+        return expectLib.extend({ ...matchers });
+    }
+    expectLib = global.jasmine;
+    return expectLib.getEnv().beforeAll(function addExpectWebdriverIOMatchers() {
+        expectLib.addMatchers({ ...matchers });
+        expectLib.addAsyncMatchers({ ...matchers });
+    });
+};
+exports.isJasmine = () => {
+    return global.jasmine && global.expect && global.expectAsync && global.jasmine.getEnv && global.jasmine.addMatchers && global.jasmine.addAsyncMatchers;
+};
+exports.loadExpect = () => {
+    try {
+        return expectLib = require('expect');
+    }
+    catch (err) {
+        return console.error('Failed to load expect package. Make sure it has been installed: npm i expect');
+    }
+};

package/lib/index.js

@@ -1,59 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-let expectLib;
-let setDefaultOptions = () => { };
-const extend = () => {
-    if (global.expect === undefined) {
-        if (!loadExpect()) {
-            return;
-        }
-        global.expect = expectLib;
-    }
-    else {
-        expectLib = global.expect;
-    }
-    if (!global.expect.extend && !isJasmine()) {
-        if (!loadExpect()) {
-            return;
-        }
-        global.ExpectWebdriverIO = expectLib;
-        console.warn('Warning! Unsupported expect lib is used.\n' +
-            "Only Jasmine >= 3.3.0 and Jest's expect are supported.\n" +
-            "expect-webdriverio is assigned to global.ExpectWebdriverIO");
-    }
-    setDefaultOptions = require('./options').setDefaultOptions;
-    const matchers = require('./matchers').default;
-    if (expectLib.extend) {
-        return expectLib.extend({ ...matchers });
-    }
-    expectLib = global.jasmine;
-    let addMatchersFn = 'addMatchers';
-    if (!isWdioSyncInstalled()) {
-        addMatchersFn = 'addAsyncMatchers';
-    }
-    return expectLib.getEnv().beforeAll(function addExpectWebdriverIOMatchers() {
-        expectLib[addMatchersFn]({ ...matchers });
-    });
-};
-const isJasmine = () => {
-    return global.jasmine && global.expect && global.expectAsync && global.jasmine.getEnv && global.jasmine.addMatchers && global.jasmine.addAsyncMatchers;
-};
-const loadExpect = () => {
-    try {
-        return expectLib = require('expect');
-    }
-    catch (err) {
-        return console.error('Failed to load expect package. Make sure it has been installed: npm i expect');
-    }
-};
-const isWdioSyncInstalled = () => {
-    try {
-        require('@wdio/sync/package.json').version;
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-};
-extend();
-exports.setOptions = setDefaultOptions;
+const addMatchers_1 = require("./addMatchers");
+addMatchers_1.addMatchers();
+exports.setOptions = require('./options').setDefaultOptions;

package/lib/matchers/element/toBeDisplayed.js

@@ -21,8 +21,6 @@ function toBeDisplayedFn(received, options = {}) {
     });
 }
 function toBeVisible(el, options) {
-    const context = expectAdapter_1.getContext(this);
-    context.expectation = 'visible';
-    return toBeDisplayed.call(context, el, options);
+    return utils_1.aliasFn.call(this, toBeDisplayed, { expectation: 'visible' }, el, options);
 }
 exports.toBeVisible = toBeVisible;

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -20,4 +20,7 @@ function toBeDisplayedInViewportFn(received, options = {}) {
         return result;
     });
 }
-exports.toBeVisibleInViewport = toBeDisplayedInViewport;
+function toBeVisibleInViewport(el, options) {
+    return utils_1.aliasFn.call(this, toBeDisplayedInViewport, { expectation: 'visible in viewport' }, el, options);
+}
+exports.toBeVisibleInViewport = toBeVisibleInViewport;

package/lib/matchers/element/toBeExisting.js

@@ -21,5 +21,11 @@ function toExistFn(received, options = {}) {
         return result;
     });
 }
-exports.toBeExisting = toExist;
-exports.toBePresent = toExist;
+function toBeExisting(el, options) {
+    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
+}
+exports.toBeExisting = toBeExisting;
+function toBePresent(el, options) {
+    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
+}
+exports.toBePresent = toBePresent;

package/lib/matchers.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const matchers = {
+    ...require('./matchers/browser/toHaveTitle'),
+    ...require('./matchers/browser/toHaveUrl'),
+    ...require('./matchers/elements/toBeElementsArrayOfSize'),
     ...require('./matchers/element/toBeClickable'),
     ...require('./matchers/element/toBeDisabled'),
     ...require('./matchers/element/toBeDisplayed'),
@@ -22,9 +25,6 @@ const matchers = {
     ...require('./matchers/element/toHaveTextContaining'),
     ...require('./matchers/element/toHaveValue'),
     ...require('./matchers/element/toHaveValueContaining'),
-    ...require('./matchers/browser/toHaveTitle'),
-    ...require('./matchers/browser/toHaveUrl'),
-    ...require('./matchers/elements/toBeElementsArrayOfSize'),
 };
 Object.keys(matchers).forEach(key => {
     if (key.endsWith('Fn')) {

package/lib/options.js

@@ -6,10 +6,10 @@ const DEFAULT_OPTIONS = {
 };
 let mode = 'jest';
 let expectLib;
-if (global.ExpectWebdriverIO) {
-    expectLib = global.ExpectWebdriverIO;
+if (global.expectWdio) {
+    expectLib = global.expectWdio;
 }
-else if (global.jasmine) {
+else if (global.jasmine && !global.expect.extend) {
     expectLib = global.jasmine;
     mode = 'jasmine';
 }

package/lib/utils.js

@@ -9,6 +9,7 @@ exports.updateElementsArray = elementsUtil_1.updateElementsArray;
 const formatMessage_1 = require("./util/formatMessage");
 exports.enhanceError = formatMessage_1.enhanceError;
 exports.numberError = formatMessage_1.numberError;
+const expectAdapter_1 = require("./util/expectAdapter");
 const config = options_1.getConfig();
 const { options: DEFAULT_OPTIONS } = config;
 const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
@@ -26,7 +27,10 @@ const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait
                 error = err;
                 return false;
             }
-        }, wait, undefined, interval);
+        }, {
+            timeout: wait,
+            interval
+        });
         if (error) {
             throw error;
         }
@@ -88,3 +92,10 @@ exports.compareText = (actual, expected, { ignoreCase = false, trim = false, con
         result: actual === expected
     };
 };
+function aliasFn(fn, { verb, expectation } = {}, ...args) {
+    const context = expectAdapter_1.getContext(this);
+    context.verb = verb;
+    context.expectation = expectation;
+    return fn.apply(context, args);
+}
+exports.aliasFn = aliasFn;

package/package.json

@@ -1,39 +1,46 @@
 {
   "name": "expect-webdriverio",
-  "version": "0.1.1-beta.5",
+  "version": "1.0.0",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
-    "test": "jest",
+    "build": "run-s clean compile",
     "clean": "rimraf ./lib",
-    "compile": "tsc",
-    "build": "run-s clean compile"
+    "compile": "tsc --build tsconfig.build.json",
+    "release": "npm run release:patch",
+    "release:patch": "np patch",
+    "release:minor": "np minor",
+    "release:major": "np major",
+    "test": "jest"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mgrybyk/expect-webdriverio.git"
+    "url": "git+https://github.com/webdriverio/expect-webdriverio.git"
   },
   "keywords": [
+    "expect-webdriverio",
     "expect",
     "webdriverio",
     "wdio"
   ],
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
-    "url": "https://github.com/mgrybyk/expect-webdriverio/issues"
+    "url": "https://github.com/webdriverio/expect-webdriverio/issues"
   },
-  "homepage": "https://github.com/mgrybyk/expect-webdriverio#readme",
+  "homepage": "https://github.com/webdriverio/expect-webdriverio#readme",
   "devDependencies": {
-    "@types/jest": "^24.0.23",
-    "@types/node": "^12.12.14",
-    "husky": "^3.1.0",
-    "jest": "^24.9.0",
+    "@types/jest": "^25.1.4",
+    "@types/node": "^12.12.31",
+    "codecov": "^3.6.5",
+    "husky": "^4.2.3",
+    "jest": "^25.2.2",
+    "np": "^6.2.0",
     "npm-run-all": "^4.1.5",
-    "rimraf": "^3.0.0",
-    "ts-jest": "^24.2.0",
-    "typescript": "^3.7.3",
-    "webdriverio": "^5.16.11"
+    "rimraf": "^3.0.2",
+    "ts-jest": "^25.2.1",
+    "typescript": "^3.8.3",
+    "webdriverio": "^6.0.2"
   },
   "types": "types/jest-global.d.ts",
   "husky": {
@@ -42,6 +49,7 @@
     }
   },
   "dependencies": {
-    "jest-matcher-utils": "^24.9.0"
+    "expect": "^25.2.1",
+    "jest-matcher-utils": "^25.1.0"
   }
 }

package/types/jest-global.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="expect-webdriverio/types/jest-expect-clone/jest-expect"/>
-/// <reference types="expect-webdriverio/jest"/>
+/// <reference types="expect-webdriverio/types/standalone"/>
 
 declare const expect: jest.Expect
 

package/types/standalone-global.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="expect-webdriverio/types/standalone"/>
+
+declare const expectWdio: jest.Expect
+
+declare namespace NodeJS {
+    interface Global {
+        expectWdio: jest.Expect
+    }
+}

package/types/standalone.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="expect-webdriverio/types/jest-expect-clone/jest-expect"/>
+/// <reference types="expect-webdriverio/jest"/>