codeceptjs 3.5.14 → 3.5.15

package/lib/command/dryRun.js

@@ -59,24 +59,39 @@ function printTests(files) {
 
   let numOfTests = 0;
   let numOfSuites = 0;
-  const filteredSuites = [];
+  let outputString = '';
+  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined;
 
-  for (const suite of mocha.suite.suites) {
-    if (process.env.grep && suite.title.toLowerCase().includes(process.env.grep)) {
-      filteredSuites.push(suite);
+  if (filterBy) {
+    for (const suite of mocha.suite.suites) {
+      const currentSuite = suite.title;
+      if (suite.title.toLowerCase().includes(filterBy)) {
+        outputString += `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests\n`;
+        numOfSuites++;
+      }
+
+      for (test of suite.tests) {
+        if (test.title.toLowerCase().includes(filterBy)) {
+          numOfTests++;
+          outputString += `${colors.white.bold(test.parent.title)} -- ${output.styles.log(test.parent.file || '')} -- ${mocha.suite.suites.length} tests\n`;
+          outputString += `  ${output.styles.scenario(figures.checkboxOff)} ${test.title}\n`;
+        }
+      }
     }
-  }
-  const displayedSuites = process.env.grep ? filteredSuites : mocha.suite.suites;
-  for (const suite of displayedSuites) {
-    output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${suite.tests.length} tests`);
-    numOfSuites++;
-
-    for (const test of suite.tests) {
-      numOfTests++;
-      output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`);
+    numOfSuites = countSuites(outputString);
+  } else {
+    for (const suite of mocha.suite.suites) {
+      output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests`);
+      numOfSuites++;
+
+      for (test of suite.tests) {
+        numOfTests++;
+        output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`);
+      }
     }
   }
 
+  output.print(removeDuplicates(outputString));
   output.print('');
   output.success(`  Total: ${numOfSuites} suites | ${numOfTests} tests  `);
   printFooter();
@@ -87,3 +102,19 @@ function printFooter() {
   output.print();
   output.print('--- DRY MODE: No tests were executed ---');
 }
+
+function removeDuplicates(inputString) {
+  const array = inputString.split('\n');
+  const uniqueLines = [...new Set(array)];
+  const resultString = uniqueLines.join('\n');
+
+  return resultString;
+}
+
+function countSuites(inputString) {
+  const array = inputString.split('\n');
+
+  const uniqueLines = [...new Set(array)];
+  const res = uniqueLines.filter(item => item.includes('-- '));
+  return res.length;
+}

package/lib/helper/Expect.js

@@ -190,7 +190,7 @@ class ExpectHelper {
      * @param {*} targetData
      * @param {*} jsonSchema
      * @param {*} [customErrorMsg]
-     * @param {*} ajvOptions Pass AJV options
+     * @param {*} [ajvOptions] Pass AJV options
      */
   expectJsonSchemaUsingAJV(
     targetData,

package/lib/helper/Puppeteer.js

@@ -78,7 +78,7 @@ const consoleLogStore = new Console();
  * @prop {string} [browser=chrome] - can be changed to `firefox` when using [puppeteer-firefox](https://codecept.io/helpers/Puppeteer-firefox).
  * @prop {object} [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
-*/
+ */
 const config = {};
 
 /**
@@ -369,7 +369,7 @@ class Puppeteer extends Helper {
         this.debugSection('Incognito Tab', 'opened');
         this.activeSessionName = name;
 
-        const bc = await this.browser.createIncognitoBrowserContext();
+        const bc = await this.browser.createBrowserContext();
         await bc.newPage();
 
         // Create a new page inside context.
@@ -599,14 +599,7 @@ class Puppeteer extends Helper {
   }
 
   async _evaluateHandeInContext(...args) {
-    let context = await this._getContext();
-
-    if (context.constructor.name === 'Frame') {
-      // Currently there is no evalateHandle for the Frame object
-      // https://github.com/GoogleChrome/puppeteer/issues/1051
-      context = await context.executionContext();
-    }
-
+    const context = await this._getContext();
     return context.evaluateHandle(...args);
   }
 
@@ -884,7 +877,8 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async _locate(locator) {
-    return findElements(await this.context, locator);
+    const context = await this.context;
+    return findElements.call(this, context, locator);
   }
 
   /**
@@ -910,7 +904,7 @@ class Puppeteer extends Helper {
    * ```
    */
   async _locateClickable(locator) {
-    const context = await this._getContext();
+    const context = await this.context;
     return findClickable.call(this, context, locator);
   }
 
@@ -1687,8 +1681,8 @@ class Puppeteer extends Helper {
    * {{> executeScript }}
    */
   async executeScript(...args) {
-    let context = this.page;
-    if (this.context && this.context.constructor.name === 'Frame') {
+    let context = await this._getContext();
+    if (this.context && this.context.constructor.name === 'CdpFrame') {
       context = this.context; // switching to iframe context
     }
     return context.evaluate.apply(context, args);
@@ -1769,7 +1763,7 @@ class Puppeteer extends Helper {
    */
   async grabHTMLFromAll(locator) {
     const els = await this._locate(locator);
-    const values = await Promise.all(els.map(el => el.executionContext().evaluate(element => element.innerHTML, el)));
+    const values = await Promise.all(els.map(el => el.evaluate(element => element.innerHTML, el)));
     return values;
   }
 
@@ -1792,7 +1786,7 @@ class Puppeteer extends Helper {
    */
   async grabCssPropertyFromAll(locator, cssProperty) {
     const els = await this._locate(locator);
-    const res = await Promise.all(els.map(el => el.executionContext().evaluate(el => JSON.parse(JSON.stringify(getComputedStyle(el))), el)));
+    const res = await Promise.all(els.map(el => el.evaluate(el => JSON.parse(JSON.stringify(getComputedStyle(el))), el)));
     const cssValues = res.map(props => props[toCamelCase(cssProperty)]);
 
     return cssValues;
@@ -1854,35 +1848,34 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeAttributesOnElements(locator, attributes) {
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
+    const elements = await this._locate(locator);
+    assertElementExists(elements, locator);
 
-    const elemAmount = res.length;
-    const commands = [];
-    res.forEach((el) => {
-      Object.keys(attributes).forEach((prop) => {
-        commands.push(el
-          .executionContext()
-          .evaluateHandle((el, attr) => el[attr] || el.getAttribute(attr), el, prop)
-          .then(el => el.jsonValue()));
-      });
-    });
-    let attrs = await Promise.all(commands);
-    const values = Object.keys(attributes).map(key => attributes[key]);
-    if (!Array.isArray(attrs)) attrs = [attrs];
-    let chunked = chunkArray(attrs, values.length);
-    chunked = chunked.filter((val) => {
-      for (let i = 0; i < val.length; ++i) {
-        const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(values[i], 10);
-        const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
-        // the attribute could be a boolean
-        if (typeof _actual === 'boolean') return _actual === _expected;
-        // if the attribute doesn't exist, returns false as well
-        if (!_actual || !_actual.includes(_expected)) return false;
-      }
-      return true;
+    const expectedAttributes = Object.entries(attributes);
+
+    const valuesPromises = elements.map(async (element) => {
+      const elementAttributes = {};
+      await Promise.all(expectedAttributes.map(async ([attribute, expectedValue]) => {
+        const actualValue = await element.evaluate((el, attr) => el[attr] || el.getAttribute(attr), attribute);
+        elementAttributes[attribute] = actualValue;
+      }));
+      return elementAttributes;
     });
-    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`).assert(chunked.length, elemAmount);
+
+    const actualAttributes = await Promise.all(valuesPromises);
+
+    const matchingElements = actualAttributes.filter((attrs) => expectedAttributes.every(([attribute, expectedValue]) => {
+      const actualValue = attrs[attribute];
+      if (!actualValue) return false;
+      if (actualValue.toString().match(new RegExp(expectedValue.toString()))) return true;
+      return expectedValue === actualValue;
+    }));
+
+    const elementsCount = elements.length;
+    const matchingCount = matchingElements.length;
+
+    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`)
+      .assert(matchingCount, elementsCount);
   }
 
   /**
@@ -2138,7 +2131,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout });
     } else {
-      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2159,7 +2152,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, visible: true });
     } else {
-      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, visible: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, visible: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2178,7 +2171,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
     } else {
-      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, hidden: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2196,7 +2189,7 @@ class Puppeteer extends Helper {
     if (locator.isCSS()) {
       waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
     } else {
-      waiter = context.waitForXPath(locator.value, { timeout: waitTimeout, hidden: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
     }
     return waiter.catch((err) => {
       throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`);
@@ -2222,7 +2215,7 @@ class Puppeteer extends Helper {
   }
 
   async _getContext() {
-    if (this.context && this.context.constructor.name === 'Frame') {
+    if (this.context && this.context.constructor.name === 'CdpFrame') {
       return this.context;
     }
     return this.page;
@@ -2345,35 +2338,37 @@ class Puppeteer extends Helper {
   async switchTo(locator) {
     if (Number.isInteger(locator)) {
       // Select by frame index of current context
-
-      let childFrames = null;
+      let frames = [];
       if (this.context && typeof this.context.childFrames === 'function') {
-        childFrames = this.context.childFrames();
+        frames = await this.context.childFrames();
       } else {
-        childFrames = this.page.mainFrame().childFrames();
+        frames = await this.page.mainFrame().childFrames();
       }
 
-      if (locator >= 0 && locator < childFrames.length) {
-        this.context = childFrames[locator];
+      if (locator >= 0 && locator < frames.length) {
+        this.context = frames[locator];
       } else {
-        throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath');
+        throw new Error('Frame index out of bounds');
       }
       return;
     }
+
     if (!locator) {
-      this.context = await this.page.mainFrame().$('body');
+      this.context = await this.page.mainFrame();
       return;
     }
 
-    // iframe by selector
+    // Select iframe by selector
     const els = await this._locate(locator);
     assertElementExists(els, locator);
-    const contentFrame = await els[0].contentFrame();
+
+    const iframeElement = els[0];
+    const contentFrame = await iframeElement.contentFrame();
 
     if (contentFrame) {
       this.context = contentFrame;
     } else {
-      this.context = els[0];
+      throw new Error('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
     }
   }
 
@@ -2469,7 +2464,7 @@ class Puppeteer extends Helper {
 module.exports = Puppeteer;
 
 async function findElements(matcher, locator) {
-  if (locator.react) return findReact(matcher.executionContext(), locator);
+  if (locator.react) return findReactElements.call(this, locator);
   locator = new Locator(locator, 'css');
   if (!locator.isXPath()) return matcher.$$(locator.simplify());
   // puppeteer version < 19.4.0 is no longer supported. This one is backward support.
@@ -2506,7 +2501,7 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
-  if (locator.react) return findReact(matcher.executionContext(), locator);
+  if (locator.react) return findReactElements.call(this, locator);
   locator = new Locator(locator);
   if (!locator.isFuzzy()) return findElements.call(this, matcher, locator);
 
@@ -2855,3 +2850,70 @@ function highlightActiveElement(element, context) {
     highlightElement(element, context);
   }
 }
+
+function _waitForElement(locator, options) {
+  try {
+    return this.context.waitForXPath(locator.value, options);
+  } catch (e) {
+    return this.context.waitForSelector(`::-p-xpath(${locator.value})`, options);
+  }
+}
+
+async function findReactElements(locator, props = {}, state = {}) {
+  const resqScript = await fs.promises.readFile(require.resolve('resq'), 'utf-8');
+  await this.page.evaluate(resqScript.toString());
+
+  await this.page.evaluate(() => window.resq.waitToLoadReact());
+  const arrayHandle = await this.page.evaluateHandle((obj) => {
+    const { selector, props, state } = obj;
+    let elements = window.resq.resq$$(selector);
+    if (Object.keys(props).length) {
+      elements = elements.byProps(props);
+    }
+    if (Object.keys(state).length) {
+      elements = elements.byState(state);
+    }
+
+    if (!elements.length) {
+      return [];
+    }
+
+    // resq returns an array of HTMLElements if the React component is a fragment
+    // this avoids having nested arrays of nodes which the driver does not understand
+    // [[div, div], [div, div]] => [div, div, div, div]
+    let nodes = [];
+
+    elements.forEach((element) => {
+      let { node, isFragment } = element;
+
+      if (!node) {
+        isFragment = true;
+        node = element.children;
+      }
+
+      if (isFragment) {
+        nodes = nodes.concat(node);
+      } else {
+        nodes.push(node);
+      }
+    });
+
+    return [...nodes];
+  }, {
+    selector: locator.react,
+    props: locator.props || {},
+    state: locator.state || {},
+  });
+
+  const properties = await arrayHandle.getProperties();
+  const result = [];
+  for (const property of properties.values()) {
+    const elementHandle = property.asElement();
+    if (elementHandle) {
+      result.push(elementHandle);
+    }
+  }
+
+  await arrayHandle.dispose();
+  return result;
+}

package/lib/plugin/coverage.js

@@ -1,44 +1,67 @@
 const debugModule = require('debug');
-const fs = require('fs');
-const path = require('path');
-
+const { CoverageReport } = require('monocart-coverage-reports');
 const Container = require('../container');
 const recorder = require('../recorder');
 const event = require('../event');
 const output = require('../output');
-const { clearString } = require('../utils');
+const { deepMerge } = require('../utils');
 
 const defaultConfig = {
-  coverageDir: 'output/coverage',
-  uniqueFileName: true,
+  name: 'CodeceptJS Coverage Report',
+  outputDir: 'output/coverage',
 };
 
 const supportedHelpers = ['Puppeteer', 'Playwright'];
 
-function buildFileName(test, uniqueFileName) {
-  let fileName = clearString(test.title);
-
-  // This prevent data driven to be included in the failed screenshot file name
-  if (fileName.indexOf('{') !== -1) {
-    fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim();
-  }
-
-  if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') {
-    fileName = clearString(`${test.title}_${test.ctx.test.title}`);
-  }
-
-  if (uniqueFileName) {
-    const uuid = test.uuid
-      || test.ctx.test.uuid
-      || Math.floor(new Date().getTime() / 1000);
-
-    fileName = `${fileName.substring(0, 10)}_${uuid}.coverage.json`;
-  } else {
-    fileName = `${fileName}.coverage.json`;
-  }
-
-  return fileName;
-}
+const v8CoverageHelpers = {
+  Playwright: {
+    startCoverage: async (page) => {
+      await Promise.all([
+        page.coverage.startJSCoverage({
+          resetOnNavigation: false,
+        }),
+        page.coverage.startCSSCoverage({
+          resetOnNavigation: false,
+        }),
+      ]);
+    },
+    takeCoverage: async (page, coverageReport) => {
+      const [jsCoverage, cssCoverage] = await Promise.all([
+        page.coverage.stopJSCoverage(),
+        page.coverage.stopCSSCoverage(),
+      ]);
+      const coverageList = [...jsCoverage, ...cssCoverage];
+      await coverageReport.add(coverageList);
+    },
+  },
+  Puppeteer: {
+    startCoverage: async (page) => {
+      await Promise.all([
+        page.coverage.startJSCoverage({
+          resetOnNavigation: false,
+          includeRawScriptCoverage: true,
+        }),
+        page.coverage.startCSSCoverage({
+          resetOnNavigation: false,
+        }),
+      ]);
+    },
+    takeCoverage: async (page, coverageReport) => {
+      const [jsCoverage, cssCoverage] = await Promise.all([
+        page.coverage.stopJSCoverage(),
+        page.coverage.stopCSSCoverage(),
+      ]);
+      // to raw V8 script coverage
+      const coverageList = [...jsCoverage.map((it) => {
+        return {
+          source: it.text,
+          ...it.rawScriptCoverage,
+        };
+      }), ...cssCoverage];
+      await coverageReport.add(coverageList);
+    },
+  },
+};
 
 /**
  * Dumps code coverage from Playwright/Puppeteer after every test.
@@ -49,94 +72,84 @@ function buildFileName(test, uniqueFileName) {
  * ```js
  * plugins: {
  *    coverage: {
- *      enabled: true
+ *      enabled: true,
+ *      debug: true,
+ *      name: 'CodeceptJS Coverage Report',
+ *      outputDir: 'output/coverage'
  *    }
  * }
  * ```
  *
- * Possible config options:
+ * Possible config options, More could be found at [monocart-coverage-reports](https://github.com/cenfun/monocart-coverage-reports?tab=readme-ov-file#default-options)
+ *
+ * * `debug`: debug info. By default, false.
+ * * `name`: coverage report name.
+ * * `outputDir`: path to coverage report.
+ * * `sourceFilter`: filter the source files.
+ * * `sourcePath`: option to resolve a custom path.
  *
- * * `coverageDir`: directory to dump coverage files
- * * `uniqueFileName`: generate a unique filename by adding uuid
  */
 module.exports = function (config) {
+  config = deepMerge(defaultConfig, config);
+
+  if (config.debug) config.logging = 'debug';
+
   const helpers = Container.helpers();
   let coverageRunning = false;
-  let helper;
 
-  let debug;
-  for (const helperName of supportedHelpers) {
-    if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
-      debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
-    }
+  const v8Names = Object.keys(v8CoverageHelpers);
+  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it));
+  if (!helperName) {
+    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`);
+    // no helpers for screenshot
+    return;
   }
 
-  if (!helper) {
-    console.error('Coverage is only supported in Puppeteer, Playwright');
-    return; // no helpers for screenshot
-  }
+  config.name = `${config.name} - in ${helperName}`;
+  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
+
+  const helper = helpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName];
 
-  const options = Object.assign(defaultConfig, helper.options, config);
+  const coverageOptions = {
+    ...config,
+  };
+  const coverageReport = new CoverageReport(coverageOptions);
+  coverageReport.cleanCache();
 
-  event.dispatcher.on(event.all.before, async () => {
-    output.debug('*** Collecting coverage for tests ****');
+  event.dispatcher.on(event.all.after, async () => {
+    output.print(`writing ${coverageOptions.outputDir}`);
+    await coverageReport.generate();
   });
 
-  //  Hack!  we're going to try to "start" coverage before each step because this is
+  //  we're going to try to "start" coverage before each step because this is
   //  when the browser is already up and is ready to start coverage.
-  event.dispatcher.on(event.step.before, async () => {
-    recorder.add(
-      'starting coverage',
-      async () => {
-        try {
-          if (!coverageRunning && helper.page && helper.page.coverage) {
-            debug('--> starting coverage <--');
-            coverageRunning = true;
-            await helper.page.coverage.startJSCoverage();
-          }
-        } catch (err) {
-          console.error(err);
-        }
-      },
-      true,
-    );
+  event.dispatcher.on(event.step.before, () => {
+    recorder.add('start coverage', async () => {
+      if (coverageRunning) {
+        return;
+      }
+      if (!helper.page || !helper.page.coverage) {
+        return;
+      }
+      coverageRunning = true;
+      debug('--> starting coverage <--');
+      await v8Helper.startCoverage(helper.page);
+    }, true);
   });
 
   // Save coverage data after every test run
-  event.dispatcher.on(event.test.after, async (test) => {
-    recorder.add(
-      'saving coverage',
-      async () => {
-        try {
-          if (coverageRunning && helper.page && helper.page.coverage) {
-            debug('--> stopping coverage <--');
-            coverageRunning = false;
-            const coverage = await helper.page.coverage.stopJSCoverage();
-
-            const coverageDir = path.resolve(
-              process.cwd(),
-              options.coverageDir,
-            );
-
-            // Checking if coverageDir already exists, if not, create new one
-
-            if (!fs.existsSync(coverageDir)) {
-              fs.mkdirSync(coverageDir, { recursive: true });
-            }
-
-            const coveragePath = path.resolve(
-              coverageDir,
-              buildFileName(test, options.uniqueFileName),
-            );
-            output.print(`writing ${coveragePath}`);
-            fs.writeFileSync(coveragePath, JSON.stringify(coverage));
-          }
-        } catch (err) {
-          console.error(err);
-        }
-      },
-      true,
-    );
+  event.dispatcher.on(event.test.after, (test) => {
+    recorder.add('take coverage', async () => {
+      if (!coverageRunning) {
+        return;
+      }
+      if (!helper.page || !helper.page.coverage) {
+        return;
+      }
+      coverageRunning = false;
+      debug('--> stopping coverage <--');
+      await v8Helper.takeCoverage(helper.page, coverageReport);
+    }, true);
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.5.14",
+  "version": "3.5.15",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -29,7 +29,7 @@
     "docs/webapi/**"
   ],
   "main": "lib/index.js",
-  "typings": "typings/index.d.ts",
+  "types": "typings/index.d.ts",
   "bin": {
     "codeceptjs": "./bin/codecept.js"
   },
@@ -62,12 +62,13 @@
     "dev:graphql": "node test/data/graphql/index.js",
     "publish:site": "./runok.js publish:site",
     "update-contributor-faces": "./runok.js contributor:faces",
-    "dtslint": "dtslint typings --localTs './node_modules/typescript/lib'",
+    "types-fix": "node typings/fixDefFiles.js",
+    "dtslint": "npm run types-fix && tsd",
     "prepare": "husky install",
     "prepare-release": "./runok.js versioning && ./runok.js get:commit-log"
   },
   "dependencies": {
-    "@codeceptjs/configure": "0.10.0",
+    "@codeceptjs/configure": "1.0.1",
     "@codeceptjs/helper": "2.0.1",
     "@cucumber/cucumber-expressions": "17",
     "@cucumber/gherkin": "26",
@@ -76,7 +77,7 @@
     "acorn": "8.11.3",
     "arrify": "2.0.1",
     "axios": "1.6.7",
-    "chai": "5.0.3",
+    "chai": "5.1.0",
     "chai-deep-match": "1.2.1",
     "chai-exclude": "2.1.0",
     "chai-json-schema": "1.5.1",
@@ -88,7 +89,7 @@
     "cross-spawn": "7.0.3",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
-    "devtools": "8.29.1",
+    "devtools": "8.33.1",
     "envinfo": "7.11.0",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
@@ -97,16 +98,17 @@
     "glob": "6.0.1",
     "html-minifier-terser": "7.2.0",
     "inquirer": "6.5.2",
-    "joi": "17.12.1",
-    "js-beautify": "1.14.11",
+    "joi": "17.12.2",
+    "js-beautify": "1.15.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
     "mkdirp": "1.0.4",
-    "mocha": "10.2.0",
+    "mocha": "10.3.0",
+    "monocart-coverage-reports": "2.7.1",
     "ms": "2.1.3",
     "openai": "3.2.1",
     "ora-classic": "5.4.2",
-    "pactum": "3.6.0",
+    "pactum": "3.6.1",
     "parse-function": "5.6.10",
     "parse5": "7.1.2",
     "promise-retry": "1.1.1",
@@ -115,7 +117,7 @@
     "uuid": "9.0"
   },
   "optionalDependencies": {
-    "@codeceptjs/detox-helper": "1.0.2"
+    "@codeceptjs/detox-helper": "1.0.5"
   },
   "devDependencies": {
     "@codeceptjs/mock-request": "0.3.1",
@@ -125,7 +127,7 @@
     "@types/chai": "4.3.11",
     "@types/inquirer": "9.0.3",
     "@types/node": "20.11.16",
-    "@wdio/sauce-service": "8.29.1",
+    "@wdio/sauce-service": "8.32.3",
     "@wdio/selenium-standalone-service": "8.3.2",
     "@wdio/utils": "8.28.8",
     "@xmldom/xmldom": "0.8.10",
@@ -134,14 +136,13 @@
     "chai-subset": "1.6.0",
     "contributor-faces": "1.1.0",
     "documentation": "12.3.0",
-    "dtslint": "4.2.1",
     "electron": "28.2.1",
     "eslint": "8.56.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.29.1",
     "eslint-plugin-mocha": "6.3.0",
     "expect": "29.7.0",
-    "express": "4.18.2",
+    "express": "4.18.3",
     "graphql": "14.6.0",
     "husky": "8.0.3",
     "inquirer-test": "2.0.1",
@@ -149,7 +150,7 @@
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.10.1",
     "playwright": "1.41.1",
-    "puppeteer": "21.1.1",
+    "puppeteer": "22.4.1",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
     "runok": "0.9.3",
@@ -158,12 +159,13 @@
     "testcafe": "3.5.0",
     "ts-morph": "21.0.1",
     "ts-node": "10.9.2",
+    "tsd": "^0.30.7",
     "tsd-jsdoc": "2.5.0",
-    "typedoc": "0.25.7",
+    "typedoc": "0.25.12",
     "typedoc-plugin-markdown": "3.17.1",
     "typescript": "5.3.3",
     "wdio-docker-service": "1.5.0",
-    "webdriverio": "8.31.1",
+    "webdriverio": "8.33.1",
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },
@@ -171,5 +173,11 @@
     "node": ">=16.0",
     "npm": ">=5.6.0"
   },
-  "es6": true
-}
+  "es6": true,
+  "tsd": {
+    "directory": "typings",
+    "compilerOptions": {
+      "strict": false
+    }
+  }
+}

package/typings/index.d.ts

@@ -8,6 +8,7 @@
 
 declare namespace CodeceptJS {
   type WithTranslation<T> = T &
+    // @ts-ignore
     import("./utils").Translate<T, Translation.Actions>;
 
   type Cookie = {

package/typings/promiseBasedTypes.d.ts

@@ -1127,9 +1127,9 @@ declare namespace CodeceptJS {
         expectNotEndsWith(actualValue: any, expectedValueToNotEndWith: any, customErrorMsg?: any): Promise<any>;
         expectJsonSchema(targetData: any, jsonSchema: any, customErrorMsg?: any): Promise<any>;
         /**
-         * @param ajvOptions - Pass AJV options
+         * @param [ajvOptions] - Pass AJV options
          */
-        expectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: any, ajvOptions: any): Promise<any>;
+        expectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: any, ajvOptions?: any): Promise<any>;
         expectHasProperty(targetData: any, propertyName: any, customErrorMsg?: any): Promise<any>;
         expectHasAProperty(targetData: any, propertyName: any, customErrorMsg?: any): Promise<any>;
         expectToBeA(targetData: any, type: any, customErrorMsg?: any): Promise<any>;

package/typings/types.d.ts

@@ -1151,9 +1151,9 @@ declare namespace CodeceptJS {
         expectNotEndsWith(actualValue: any, expectedValueToNotEndWith: any, customErrorMsg?: any): void;
         expectJsonSchema(targetData: any, jsonSchema: any, customErrorMsg?: any): void;
         /**
-         * @param ajvOptions - Pass AJV options
+         * @param [ajvOptions] - Pass AJV options
          */
-        expectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: any, ajvOptions: any): void;
+        expectJsonSchemaUsingAJV(targetData: any, jsonSchema: any, customErrorMsg?: any, ajvOptions?: any): void;
         expectHasProperty(targetData: any, propertyName: any, customErrorMsg?: any): void;
         expectHasAProperty(targetData: any, propertyName: any, customErrorMsg?: any): void;
         expectToBeA(targetData: any, type: any, customErrorMsg?: any): void;
@@ -12184,14 +12184,14 @@ declare namespace CodeceptJS {
      * Detox provides a grey box testing for mobile applications, playing especially good for React Native apps.
      *
      * Detox plays quite differently from Appium. To establish detox testing you need to build a mobile application in a special way to inject Detox code.
-     * This why **Detox is grey box testing** solution, so you need an access to application source code, and a way to build and execute it on emulator.
+     * This why **Detox is grey box testing** solution, so you need access to application source code, and a way to build and execute it on emulator.
      *
      * Comparing to Appium, Detox runs faster and more stable but requires an additional setup for build.
      *
      * ### Setup
      *
-     * 1. [Install and configure Detox for iOS](https://github.com/wix/Detox/blob/master/docs/Introduction.GettingStarted.md) and [Android](https://github.com/wix/Detox/blob/master/docs/Introduction.Android.md)
-     * 2. [Build an application](https://github.com/wix/Detox/blob/master/docs/Introduction.GettingStarted.md#step-4-build-your-app-and-run-detox-tests) using `detox build` command.
+     * 1. [Install and configure Detox](https://wix.github.io/Detox/docs/introduction/project-setup)
+     * 2. [Build an application](https://wix.github.io/Detox/docs/introduction/project-setup#step-5-build-the-app) using `detox build` command.
      * 3. Install [CodeceptJS](https://codecept.io) and detox-helper:
      *
      * ```
@@ -12204,15 +12204,28 @@ declare namespace CodeceptJS {
      *
      * ```js
      *  "detox": {
-     *    "configurations": {
-     *      "ios.sim.debug": {
-     *        "binaryPath": "ios/build/Build/Products/Debug-iphonesimulator/example.app",
-     *        "build": "xcodebuild -project ios/example.xcodeproj -scheme example -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build",
-     *        "type": "ios.simulator",
-     *        "name": "iPhone 7"
-     *      }
-     *    }
-     *  }
+     *     "configurations": {
+     *       "ios.sim.debug": {
+     *         "device": "simulator",
+     *         "app": "ios.debug"
+     *       }
+     *     },
+     *     "apps": {
+     *       "ios.debug": {
+     *         "type": "ios.app",
+     *         "binaryPath": "../test/ios/build/Build/Products/Debug-iphonesimulator/MyTestApp.app",
+     *         "build": "xcodebuild -workspace ../test/ios/MyTestApp.xcworkspace -scheme MyTestApp -configuration Debug -sdk iphonesimulator -derivedDataPath ../test/ios/build"
+     *       }
+     *     },
+     *     "devices": {
+     *       "simulator": {
+     *         "type": "ios.simulator",
+     *         "device": {
+     *           "type": "iPhone 15"
+     *         }
+     *       }
+     *     }
+     *   }
      * ```
      *
      *
@@ -12307,6 +12320,14 @@ declare namespace CodeceptJS {
          * ```
          */
         setPortraitOrientation(): void;
+        /**
+         * Grab the device platform
+         *
+         * ```js
+         * const platform = await I.grabPlatform();
+         * ```
+         */
+        grabPlatform(): void;
         /**
          * Execute code only on iOS
          *
@@ -12396,6 +12417,19 @@ declare namespace CodeceptJS {
          * ```
          */
         click(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString | null): void;
+        /**
+         * Clicks on an element.
+         * Element can be located by its label
+         *
+         * The second parameter is a context (id | type | accessibility id) to narrow the search.
+         *
+         *
+         * ```js
+         * I.tapByLabel('Login'); // locate by text
+         * I.tapByLabel('Login', '#nav'); // locate by text inside #nav
+         * ```
+         */
+        tapByLabel(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString | null): void;
         /**
          * Performs click on element with horizontal and vertical offset.
          * An element is located by text, id, accessibility id.
@@ -12446,6 +12480,17 @@ declare namespace CodeceptJS {
          * @param [context = null] - context element
          */
         seeElement(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString | null): void;
+        /**
+         * Checks if an element exists.
+         *
+         * ```js
+         * I.checkIfElementExists('~edit'); // located by accessibility id
+         * I.checkIfElementExists('~edit', '#menu'); // element inside #menu
+         * ```
+         * @param locator - element to locate
+         * @param [context = null] - context element
+         */
+        checkIfElementExists(locator: CodeceptJS.LocatorOrString, context?: CodeceptJS.LocatorOrString | null): void;
         /**
          * Checks that element is not visible.
          * Use second parameter to narrow down the search.
@@ -12495,6 +12540,18 @@ declare namespace CodeceptJS {
          * @param value - value to fill
          */
         fillField(field: CodeceptJS.LocatorOrString, value: string): void;
+        /**
+         * Taps return key.
+         * A field can be located by text, accessibility id, id.
+         *
+         * ```js
+         * I.tapReturnKey('Username');
+         * I.tapReturnKey('~name');
+         * I.tapReturnKey({ android: 'NAME', ios: 'name' });
+         * ```
+         * @param field - an input element to fill in
+         */
+        tapReturnKey(field: CodeceptJS.LocatorOrString): void;
         /**
          * Clears a text field.
          * A field can be located by text, accessibility id, id.
@@ -12620,7 +12677,7 @@ declare namespace CodeceptJS {
          */
         waitForElementVisible(locator: CodeceptJS.LocatorOrString, sec?: number): void;
         /**
-         * Waits an elment to become not visible.
+         * Waits an elmenet to become not visible.
          *
          * ```js
          * I.waitToHide('#message', 2); // wait for 2 seconds
@@ -12629,6 +12686,14 @@ declare namespace CodeceptJS {
          * @param [sec = 5] - number of seconds to wait
          */
         waitToHide(locator: CodeceptJS.LocatorOrString, sec?: number): void;
+        /**
+         * Scrolls within a scrollable container to an element.
+         * @param targetLocator - Locator of the element to scroll to
+         * @param containerLocator - Locator of the scrollable container
+         * @param direction - 'up' or 'down'
+         * @param [offset = 100] - Offset for scroll, can be adjusted based on need
+         */
+        scrollToElement(targetLocator: CodeceptJS.LocatorOrString, containerLocator: CodeceptJS.LocatorOrString, direction?: string, offset?: number): void;
     }
     /**
      * Abstract class.