codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.esm-aria

package/lib/workers.js

@@ -1,36 +1,41 @@
-const path = require('path')
-const mkdirp = require('mkdirp')
-const { Worker } = require('worker_threads')
-const { EventEmitter } = require('events')
-const ms = require('ms')
-const Codecept = require('./codecept')
-const MochaFactory = require('./mocha/factory')
-const Container = require('./container')
-const { getTestRoot } = require('./command/utils')
-const { isFunction, fileExists } = require('./utils')
-const { replaceValueDeep, deepClone } = require('./utils')
-const mainConfig = require('./config')
-const output = require('./output')
-const event = require('./event')
-const { deserializeTest } = require('./mocha/test')
-const { deserializeSuite } = require('./mocha/suite')
-const recorder = require('./recorder')
-const runHook = require('./hooks')
-const WorkerStorage = require('./workerStorage')
-const collection = require('./command/run-multiple/collection')
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import { mkdirp } from 'mkdirp'
+import { Worker } from 'worker_threads'
+import { EventEmitter } from 'events'
+import ms from 'ms'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+import Codecept from './codecept.js'
+import MochaFactory from './mocha/factory.js'
+import Container from './container.js'
+import { getTestRoot } from './command/utils.js'
+import { isFunction, fileExists, replaceValueDeep, deepClone } from './utils.js'
+import mainConfig from './config.js'
+import output from './output.js'
+import event from './event.js'
+import { deserializeTest } from './mocha/test.js'
+import { deserializeSuite } from './mocha/suite.js'
+import recorder from './recorder.js'
+import runHook from './hooks.js'
+import WorkerStorage from './workerStorage.js'
+import { createRuns } from './command/run-multiple/collection.js'
 
 const pathToWorker = path.join(__dirname, 'command', 'workers', 'runTests.js')
 
-const initializeCodecept = (configPath, options = {}) => {
-  const codecept = new Codecept(mainConfig.load(configPath || '.'), options)
-  codecept.init(getTestRoot(configPath))
+const initializeCodecept = async (configPath, options = {}) => {
+  const config = await mainConfig.load(configPath || '.')
+  const codecept = new Codecept(config, options)
+  await codecept.init(getTestRoot(configPath))
   codecept.loadTests()
 
   return codecept
 }
 
-const createOutputDir = configPath => {
-  const config = mainConfig.load(configPath || '.')
+const createOutputDir = async configPath => {
+  const config = await mainConfig.load(configPath || '.')
   const testRoot = getTestRoot(configPath)
   const outputDir = path.isAbsolute(config.output) ? config.output : path.join(testRoot, config.output)
 
@@ -58,8 +63,28 @@ const createWorker = (workerObject, isPoolMode = false) => {
       workerIndex: workerObject.workerIndex + 1,
       poolMode: isPoolMode,
     },
+    stdout: true,
+    stderr: true,
+  })
+  
+  // Pipe worker stdout/stderr to main process
+  if (worker.stdout) {
+    worker.stdout.setEncoding('utf8')
+    worker.stdout.on('data', (data) => {
+      process.stdout.write(data)
+    })
+  }
+  if (worker.stderr) {
+    worker.stderr.setEncoding('utf8')
+    worker.stderr.on('data', (data) => {
+      process.stderr.write(data)
+    })
+  }
+  
+  worker.on('error', err => {
+    console.error(`[Main] Worker Error:`, err)
+    output.error(`Worker Error: ${err.stack}`)
   })
-  worker.on('error', err => output.error(`Worker Error: ${err.stack}`))
 
   WorkerStorage.addWorker(worker)
   return worker
@@ -99,7 +124,7 @@ const createWorkerObjects = (testGroups, config, testRoot, options, selectedRuns
     currentMochaJunitReporterFile = config.mocha.reporterOptions['mocha-junit-reporter'].options.mochaFile
   }
 
-  collection.createRuns(selectedRuns, config).forEach(worker => {
+  createRuns(selectedRuns, config).forEach(worker => {
     const separator = path.sep
     const _config = { ...config }
     let workerName = worker.name.replace(':', '_')
@@ -196,9 +221,31 @@ class WorkerObject {
 
   addConfig(config) {
     const oldConfig = JSON.parse(this.options.override || '{}')
+    
+    // Remove customLocatorStrategies from both old and new config before JSON serialization
+    // since functions cannot be serialized and will be lost, causing workers to have empty strategies
+    const configWithoutFunctions = { ...config }
+    
+    // Clean both old and new config
+    const cleanConfig = (cfg) => {
+      if (cfg.helpers) {
+        cfg.helpers = { ...cfg.helpers }
+        Object.keys(cfg.helpers).forEach(helperName => {
+          if (cfg.helpers[helperName] && cfg.helpers[helperName].customLocatorStrategies !== undefined) {
+            cfg.helpers[helperName] = { ...cfg.helpers[helperName] }
+            delete cfg.helpers[helperName].customLocatorStrategies
+          }
+        })
+      }
+      return cfg
+    }
+    
+    const cleanedOldConfig = cleanConfig(oldConfig)
+    const cleanedNewConfig = cleanConfig(configWithoutFunctions)
+    
     const newConfig = {
-      ...oldConfig,
-      ...config,
+      ...cleanedOldConfig,
+      ...cleanedNewConfig,
     }
     this.options.override = JSON.stringify(newConfig)
   }
@@ -231,7 +278,10 @@ class Workers extends EventEmitter {
   constructor(numberOfWorkers, config = { by: 'test' }) {
     super()
     this.setMaxListeners(50)
-    this.codecept = initializeCodecept(config.testConfig, config.options)
+    this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
+    this.codecept = null
+    this.config = config  // Save config
+    this.numberOfWorkersRequested = numberOfWorkers  // Save requested worker count
     this.options = config.options || {}
     this.errors = []
     this.numberOfWorkers = 0
@@ -245,11 +295,30 @@ class Workers extends EventEmitter {
     this.maxWorkers = numberOfWorkers // Track original worker count for pool mode
 
     createOutputDir(config.testConfig)
-    if (numberOfWorkers) this._initWorkers(numberOfWorkers, config)
+    // Defer worker initialization until codecept is ready
+  }
+
+  async _ensureInitialized() {
+    if (!this.codecept) {
+      this.codecept = await this.codeceptPromise
+      // Initialize workers in these cases:
+      // 1. Positive number requested AND no manual workers pre-spawned
+      // 2. Function-based grouping (indicated by negative number) AND no manual workers pre-spawned
+      const shouldAutoInit = this.workers.length === 0 && (
+        (Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) ||
+        (this.numberOfWorkersRequested < 0 && isFunction(this.config.by))
+      )
+      
+      if (shouldAutoInit) {
+        this._initWorkers(this.numberOfWorkersRequested, this.config)
+      }
+    }
   }
 
   _initWorkers(numberOfWorkers, config) {
     this.splitTestsByGroups(numberOfWorkers, config)
+    // For function-based grouping, use the actual number of test groups created
+    const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
     this.workers = createWorkerObjects(this.testGroups, this.codecept.config, config.testConfig, config.options, config.selectedRuns)
     this.numberOfWorkers = this.workers.length
   }
@@ -302,7 +371,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(numberOfWorkers) {
-    const files = this.codecept.testFiles
+  // If Codecept isn't initialized yet, return empty groups as a safe fallback
+  if (!this.codecept) return populateGroups(numberOfWorkers)
+  const files = this.codecept.testFiles
     const mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
@@ -340,70 +411,49 @@ class Workers extends EventEmitter {
       return
     }
 
-    const files = this.codecept.testFiles
-    if (!files || files.length === 0) {
+    // Ensure codecept is initialized
+    if (!this.codecept) {
+      output.log('Warning: codecept not initialized when initializing test pool')
       this.testPoolInitialized = true
       return
     }
 
-    try {
-      const mocha = Container.mocha()
-      mocha.files = files
-      mocha.loadFiles()
-
-      mocha.suite.eachTest(test => {
-        if (test) {
-          this.testPool.push(test.uid)
-        }
-      })
-    } catch (e) {
-      // If mocha loading fails due to state pollution, skip
-    }
-
-    // If no tests were found, fallback to using createGroupsOfTests approach
-    // This works around state pollution issues
-    if (this.testPool.length === 0 && files.length > 0) {
-      try {
-        const testGroups = this.createGroupsOfTests(2) // Use 2 as a default for fallback
-        for (const group of testGroups) {
-          this.testPool.push(...group)
-        }
-      } catch (e) {
-        // If createGroupsOfTests fails, fallback to simple file names
-        for (const file of files) {
-          this.testPool.push(`test_${file.replace(/[^a-zA-Z0-9]/g, '_')}`)
-        }
-      }
+    const files = this.codecept.testFiles
+    if (!files || files.length === 0) {
+      this.testPoolInitialized = true
+      return
     }
 
-    // Last resort fallback for unit tests - add dummy test UIDs
-    if (this.testPool.length === 0) {
-      for (let i = 0; i < Math.min(files.length, 5); i++) {
-        this.testPool.push(`dummy_test_${i}_${Date.now()}`)
-      }
+    // In ESM, test UIDs are not stable across different mocha instances
+    // So instead of using UIDs, we distribute test FILES
+    // Each file may contain multiple tests
+    for (const file of files) {
+      this.testPool.push(file)
     }
-
+    
     this.testPoolInitialized = true
   }
 
   /**
    * Gets the next test from the pool
-   * @returns {String|null} test uid or null if no tests available
+   * @returns {String|null} test file path or null if no tests available
    */
   getNextTest() {
-    // Initialize test pool lazily on first access
+    // Lazy initialization of test pool on first call
     if (!this.testPoolInitialized) {
       this._initializeTestPool()
     }
-
-    return this.testPool.shift() || null
+    
+    return this.testPool.shift()
   }
 
   /**
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(numberOfWorkers) {
-    const files = this.codecept.testFiles
+  // If Codecept isn't initialized yet, return empty groups as a safe fallback
+  if (!this.codecept) return populateGroups(numberOfWorkers)
+  const files = this.codecept.testFiles
     const groups = populateGroups(numberOfWorkers)
 
     const mocha = Container.mocha()
@@ -430,23 +480,34 @@ class Workers extends EventEmitter {
   }
 
   async bootstrapAll() {
+    await this._ensureInitialized()
     return runHook(this.codecept.config.bootstrapAll, 'bootstrapAll')
   }
 
   async teardownAll() {
+    await this._ensureInitialized()
     return runHook(this.codecept.config.teardownAll, 'teardownAll')
   }
 
-  run() {
+  async run() {
+    await this._ensureInitialized()
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
-    recorder.add('starting workers', () => {
-      for (const worker of this.workers) {
-        const workerThread = createWorker(worker, this.isPoolMode)
-        this._listenWorkerEvents(workerThread)
-      }
+    
+    // Create workers and set up message handlers immediately (not in recorder queue)
+    // This prevents a race condition where workers start sending messages before handlers are attached
+    const workerThreads = []
+    for (const worker of this.workers) {
+      const workerThread = createWorker(worker, this.isPoolMode)
+      this._listenWorkerEvents(workerThread)
+      workerThreads.push(workerThread)
+    }
+    
+    recorder.add('workers started', () => {
+      // Workers are already running, this is just a placeholder step
     })
+    
     return new Promise(resolve => {
       this.on('end', resolve)
     })
@@ -522,16 +583,48 @@ class Workers extends EventEmitter {
           this.emit(event.test.started, deserializeTest(message.data))
           break
         case event.test.failed:
-          this.emit(event.test.failed, deserializeTest(message.data))
+          // For hook failures, emit immediately as there won't be a test.finished event
+          // Regular test failures are handled via test.finished to support retries
+          if (message.data?.hookName) {
+            this.emit(event.test.failed, deserializeTest(message.data))
+          }
+          // Otherwise skip - we'll emit based on finished state
           break
         case event.test.passed:
-          this.emit(event.test.passed, deserializeTest(message.data))
+          // Skip individual passed events - we'll emit based on finished state  
           break
         case event.test.skipped:
           this.emit(event.test.skipped, deserializeTest(message.data))
           break
         case event.test.finished:
-          this.emit(event.test.finished, deserializeTest(message.data))
+          // Handle different types of test completion properly
+          {
+            const data = message.data
+            const uid = data?.uid
+            const isFailed = !!data?.err || data?.state === 'failed'
+            
+            if (uid) {
+              // Track states for each test UID
+              if (!this._testStates) this._testStates = new Map()
+              
+              if (!this._testStates.has(uid)) {
+                this._testStates.set(uid, { states: [], lastData: data })
+              }
+              
+              const testState = this._testStates.get(uid)
+              testState.states.push({ isFailed, data })
+              testState.lastData = data
+            } else {
+              // For tests without UID, emit immediately
+              if (isFailed) {
+                this.emit(event.test.failed, deserializeTest(data))
+              } else {
+                this.emit(event.test.passed, deserializeTest(data))
+              }
+            }
+            
+            this.emit(event.test.finished, deserializeTest(data))
+          }
           break
         case event.test.after:
           this.emit(event.test.after, deserializeTest(message.data))
@@ -548,6 +641,11 @@ class Workers extends EventEmitter {
         case event.step.failed:
           this.emit(event.step.failed, message.data, message.data.error)
           break
+        case event.hook.failed:
+          // Hook failures are already reported as test failures by the worker
+          // Just emit the hook.failed event for listeners
+          this.emit(event.hook.failed, message.data)
+          break
       }
     })
 
@@ -578,6 +676,38 @@ class Workers extends EventEmitter {
       process.exitCode = 0
     }
 
+    // Emit states for all tracked tests before emitting results
+    if (this._testStates) {
+      for (const [uid, { states, lastData }] of this._testStates) {
+        // For tests with retries configured, emit all failures + final success
+        // For tests without retries, emit only final state
+        const lastState = states[states.length - 1]
+        
+        // Check if this test had retries by looking for failure followed by success
+        const hasRetryPattern = states.length > 1 && 
+          states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
+        
+        if (hasRetryPattern) {
+          // Emit all intermediate failures and final success for retries
+          for (const state of states) {
+            if (state.isFailed) {
+              this.emit(event.test.failed, deserializeTest(state.data))
+            } else {
+              this.emit(event.test.passed, deserializeTest(state.data))
+            }
+          }
+        } else {
+          // For non-retries (like step failures), emit only the final state
+          if (lastState.isFailed) {
+            this.emit(event.test.failed, deserializeTest(lastState.data))
+          } else {
+            this.emit(event.test.passed, deserializeTest(lastState.data))
+          }
+        }
+      }
+      this._testStates.clear()
+    }
+
     this.emit(event.all.result, Container.result())
     event.dispatcher.emit(event.workers.result, Container.result())
     this.emit('end') // internal event
@@ -602,10 +732,10 @@ class Workers extends EventEmitter {
       this.failuresLog.forEach(log => output.print(...log))
     }
 
-    output.result(result.stats.passes, result.stats.failures, result.stats.pending, ms(result.duration), result.stats.failedHooks)
+    output.result(result.stats?.passes || 0, result.stats?.failures || 0, result.stats?.pending || 0, ms(result.duration), result.stats?.failedHooks || 0)
 
     process.env.RUNS_WITH_WORKERS = 'false'
   }
 }
 
-module.exports = Workers
+export default Workers

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "codeceptjs",
-  "version": "3.7.6-beta.4",
+  "version": "4.0.0-beta.10.esm-aria",
+  "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -8,7 +9,6 @@
     "end 2 end",
     "puppeteer",
     "webdriver",
-    "testcafe",
     "playwright",
     "bdd",
     "tdd",
@@ -40,47 +40,49 @@
     "./lib/*": "./lib/*.js",
     "./els": "./lib/els.js",
     "./effects": "./lib/effects.js",
-    "./steps": "./lib/steps.js"
+    "./steps": "./lib/steps.js",
+    "./store": "./lib/store.js"
   },
   "bin": {
     "codeceptjs": "./bin/codecept.js"
   },
   "repository": "Codeception/codeceptjs",
   "scripts": {
-    "test-server": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010",
+    "test-server": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010 --read-only",
+    "test-server:writable": "node bin/test-server.js test/data/rest/db.json --host 0.0.0.0 -p 8010",
     "mock-server:start": "node test/mock-server/start-mock-server.js",
     "mock-server:stop": "kill -9 $(lsof -t -i:3001)",
     "test:with-mock-server": "npm run mock-server:start && npm test",
     "json-server:graphql": "node test/data/graphql/index.js",
-    "lint": "eslint bin/ examples/ lib/ test/ translations/ runok.js",
-    "lint-fix": "eslint bin/ examples/ lib/ test/ translations/ runok.js --fix",
-    "prettier": "prettier --config prettier.config.js --write bin/**/*.js lib/**/*.js test/**/*.js translations/**/*.js runok.js",
-    "docs": "./runok.js docs",
-    "test:unit": "mocha test/unit --recursive --timeout 10000",
-    "test:runner": "mocha test/runner --recursive --timeout 10000",
-    "test": "npm run test:unit && npm run test:runner",
-    "test:appium-quick": "mocha test/helper/Appium_test.js --grep 'quick'",
-    "test:appium-other": "mocha test/helper/Appium_test.js --grep 'second'",
-    "test:ios:appium-quick": "mocha test/helper/Appium_ios_test.js --grep 'quick'",
-    "test:ios:appium-other": "mocha test/helper/Appium_ios_test.js --grep 'second'",
+    "lint": "eslint bin/ examples/ lib/ test/ translations/ runok.cjs",
+    "lint-fix": "eslint bin/ examples/ lib/ test/ translations/ runok.cjs --fix",
+    "prettier": "prettier --config prettier.config.js --write bin/**/*.js lib/**/*.js test/**/*.js translations/**/*.js runok.cjs",
+    "docs": "./runok.cjs docs",
+    "test:unit": "mocha test/unit --recursive --timeout 10000 --reporter @testomatio/reporter/mocha",
+    "test:rest": "mocha test/rest --recursive --timeout 20000 --reporter @testomatio/reporter/mocha",
+    "test:runner": "mocha test/runner --recursive --timeout 10000 --reporter @testomatio/reporter/mocha",
+    "test": "npm run test:unit && npm run test:rest && npm run test:runner",
+    "test:appium-quick": "mocha test/helper/Appium_test.js --grep 'quick' --reporter @testomatio/reporter/mocha",
+    "test:appium-other": "mocha test/helper/Appium_test.js --grep 'second' --reporter @testomatio/reporter/mocha",
+    "test:ios:appium-quick": "mocha test/helper/Appium_ios_test.js --grep 'quick' --reporter @testomatio/reporter/mocha",
+    "test:ios:appium-other": "mocha test/helper/Appium_ios_test.js --grep 'second' --reporter @testomatio/reporter/mocha",
     "test-app:start": "php -S 127.0.0.1:8000 -t test/data/app",
     "test-app:stop": "kill -9 $(lsof -t -i:8000)",
-    "test:unit:webbapi:playwright": "mocha test/helper/Playwright_test.js",
-    "test:unit:webbapi:puppeteer": "mocha test/helper/Puppeteer_test.js",
-    "test:unit:webbapi:webDriver": "mocha test/helper/WebDriver_test.js --timeout 10000",
-    "test:unit:webbapi:webDriver:noSeleniumServer": "mocha test/helper/WebDriver.noSeleniumServer_test.js --timeout 10000",
-    "test:unit:webbapi:testCafe": "mocha test/helper/TestCafe_test.js",
-    "test:unit:expect": "mocha test/helper/Expect_test.js",
-    "test:plugin": "mocha test/plugin/plugin_test.js",
-    "def": "./runok.js def",
+    "test:unit:webbapi:playwright": "mocha test/helper/Playwright_test.js --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:puppeteer": "mocha test/helper/Puppeteer_test.js --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:webDriver": "mocha test/helper/WebDriver_test.js --timeout 10000 --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:webDriver:noSeleniumServer": "mocha test/helper/WebDriver.noSeleniumServer_test.js --timeout 10000 --reporter @testomatio/reporter/mocha",
+    "test:unit:expect": "mocha test/helper/Expect_test.js --reporter @testomatio/reporter/mocha",
+    "test:plugin": "mocha test/plugin/plugin_test.js --reporter @testomatio/reporter/mocha",
+    "def": "./runok.cjs def",
     "dev:graphql": "node test/data/graphql/index.js",
-    "publish:site": "./runok.js publish:site",
-    "update-contributor-faces": "./runok.js contributor:faces",
+    "publish:site": "./runok.cjs publish:site",
+    "update-contributor-faces": "./runok.cjs contributor:faces",
     "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",
-    "publish-beta": "./runok.js publish:next-beta-version"
+    "prepare-release": "./runok.cjs versioning && ./runok.cjs get:commit-log",
+    "publish-beta": "./runok.cjs publish:next-beta-version"
   },
   "dependencies": {
     "@codeceptjs/configure": "1.0.6",
@@ -90,6 +92,7 @@
     "@cucumber/messages": "29.0.1",
     "@xmldom/xmldom": "0.9.8",
     "acorn": "8.15.0",
+    "ai": "^5.0.60",
     "arrify": "3.0.0",
     "axios": "1.12.2",
     "chalk": "4.1.2",
@@ -99,7 +102,7 @@
     "cross-spawn": "7.0.6",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
-    "envinfo": "7.15.0",
+    "envinfo": "7.20.0",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
     "fn-args": "4.0.0",
@@ -115,7 +118,7 @@
     "lodash.merge": "4.6.2",
     "lodash.shuffle": "4.2.0",
     "mkdirp": "3.0.1",
-    "mocha": "11.7.2",
+    "mocha": "11.7.5",
     "monocart-coverage-reports": "2.12.9",
     "ms": "2.1.3",
     "multer": "^2.0.2",
@@ -137,16 +140,19 @@
     "@eslint/eslintrc": "3.3.1",
     "@eslint/js": "9.36.0",
     "@faker-js/faker": "9.8.0",
+    "@inquirer/testing": "^2.1.49",
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "6.0.6",
+    "@testomatio/reporter": "^2.3.1",
     "@types/chai": "5.2.2",
     "@types/inquirer": "9.0.9",
-    "@types/node": "^24.6.2",
+    "@types/node": "^24.9.2",
     "@wdio/sauce-service": "9.12.5",
     "@wdio/selenium-standalone-service": "8.15.0",
-    "@wdio/utils": "9.19.2",
+    "@wdio/utils": "9.20.0",
     "@xmldom/xmldom": "0.9.8",
-    "chai": "^4.0.0",
+    "bunosh": "latest",
+    "chai": "^4.5.0",
     "chai-as-promised": "7.1.2",
     "chai-subset": "1.6.0",
     "documentation": "14.0.3",
@@ -160,7 +166,6 @@
     "graphql": "16.11.0",
     "graphql-tag": "^2.12.6",
     "husky": "9.1.7",
-    "inquirer-test": "2.0.1",
     "jsdoc": "^3.6.11",
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.17.4",
@@ -170,12 +175,11 @@
     "puppeteer": "24.15.0",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
-    "runok": "0.9.3",
-    "semver": "7.7.2",
+    "runok": "^0.9.3",
+    "semver": "7.7.3",
     "sinon": "21.0.0",
     "sinon-chai": "3.7.0",
-    "testcafe": "3.7.2",
-    "ts-morph": "26.0.0",
+    "ts-morph": "27.0.2",
     "ts-node": "10.9.2",
     "tsd": "^0.33.0",
     "tsd-jsdoc": "2.5.0",

package/translations/de-DE.js

@@ -1,7 +1,7 @@
-const { gherkinTranslations } = require('./utils')
+import { gherkinTranslations } from './utils.js'
 const langCode = 'de'
 
-module.exports = {
+export default {
   I: 'Ich',
   contexts: {
     ...gherkinTranslations(langCode),

package/translations/fr-FR.js

@@ -1,7 +1,7 @@
-const { gherkinTranslations } = require('./utils')
+import { gherkinTranslations } from './utils.js'
 const langCode = 'fr'
 
-module.exports = {
+export default {
   I: 'Je',
   contexts: {
     ...gherkinTranslations(langCode),

package/translations/index.js

@@ -1,10 +1,23 @@
-exports['de-DE'] = require('./de-DE')
-exports['it-IT'] = require('./it-IT')
-exports['fr-FR'] = require('./fr-FR')
-exports['ja-JP'] = require('./ja-JP')
-exports['pl-PL'] = require('./pl-PL')
-exports['pt-BR'] = require('./pt-BR')
-exports['ru-RU'] = require('./ru-RU')
-exports['zh-CN'] = require('./zh-CN')
-exports['zh-TW'] = require('./zh-TW')
-exports['nl-NL'] = require('./nl-NL')
+import deDE from './de-DE.js'
+import itIT from './it-IT.js'
+import frFR from './fr-FR.js'
+import jaJP from './ja-JP.js'
+import plPL from './pl-PL.js'
+import ptBR from './pt-BR.js'
+import ruRU from './ru-RU.js'
+import zhCN from './zh-CN.js'
+import zhTW from './zh-TW.js'
+import nlNL from './nl-NL.js'
+
+export default {
+  'de-DE': deDE,
+  'it-IT': itIT,
+  'fr-FR': frFR,
+  'ja-JP': jaJP,
+  'pl-PL': plPL,
+  'pt-BR': ptBR,
+  'ru-RU': ruRU,
+  'zh-CN': zhCN,
+  'zh-TW': zhTW,
+  'nl-NL': nlNL
+}