codeceptjs 4.0.1-beta.2 → 4.0.1-beta.21

package/lib/locator.js

@@ -5,7 +5,7 @@ import { createRequire } from 'module'
 const require = createRequire(import.meta.url)
 let cssToXPath
 
-const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'pw', 'role']
+const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'role']
 /** @class */
 class Locator {
   /**
@@ -24,19 +24,16 @@ class Locator {
      */
     this.strict = false
 
+    if (typeof locator === 'string' && this.parsedJsonAsString(locator)) {
+      return
+    }
+
     if (typeof locator === 'object') {
       if (locator.constructor.name === 'Locator') {
         Object.assign(this, locator)
         return
       }
-
-      this.locator = locator
-      this.type = Object.keys(locator)[0]
-      this.value = locator[this.type]
-      this.strict = true
-
-      Locator.filters.forEach(f => f(locator, this))
-
+      this._applyObjectLocator(locator)
       return
     }
 
@@ -53,8 +50,9 @@ class Locator {
     if (isShadow(locator)) {
       this.type = 'shadow'
     }
-    if (isPlaywrightLocator(locator)) {
-      this.type = 'pw'
+    if (isReactVueLocator(locator)) {
+      // React/Vue locators - keep as fuzzy type, helpers will handle them specially
+      this.type = 'fuzzy'
     }
 
     Locator.filters.forEach(f => f(locator, this))
@@ -76,8 +74,6 @@ class Locator {
         return this.value
       case 'shadow':
         return { shadow: this.value }
-      case 'pw':
-        return { pw: this.value }
       case 'role':
         return `[role="${this.value}"]`
     }
@@ -86,14 +82,52 @@ class Locator {
 
   toStrict() {
     if (!this.type) return null
+    if (this.type === 'role' && this.locator) {
+      return this.locator
+    }
     return { [this.type]: this.value }
   }
 
+  parsedJsonAsString(locator) {
+    if (typeof locator !== 'string') {
+      return false
+    }
+
+    const trimmed = locator.trim()
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+      return false
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed)
+      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+        this._applyObjectLocator(parsed)
+        return true
+      }
+    } catch (e) {
+    }
+    return false
+  }
+
+  _applyObjectLocator(locator) {
+    this.strict = true
+    this.locator = locator
+    const keys = Object.keys(locator)
+    const [type] = keys
+    this.type = type
+    this.value = keys.length > 1 ? locator : locator[type]
+    Locator.filters.forEach(f => f(locator, this))
+  }
+
   /**
    * @returns {string}
    */
   toString() {
-    return this.output || `{${this.type}: ${this.value}}`
+    if (this.output) return this.output
+    if (this.locator && this.value === this.locator) {
+      return JSON.stringify(this.locator)
+    }
+    return `{${this.type}: ${this.value}}`
   }
 
   /**
@@ -127,17 +161,27 @@ class Locator {
   /**
    * @returns {boolean}
    */
-  isPlaywrightLocator() {
-    return this.type === 'pw'
+  isRole() {
+    return this.type === 'role'
   }
 
   /**
-   * @returns {boolean}
+   * @returns {{role: string, options: object}|null}
    */
-  isRole() {
-    return this.type === 'role'
+  getRoleOptions() {
+    if (!this.isRole()) return null
+    const data = this.locator && typeof this.locator === 'object' ? this.locator : { role: this.value }
+    const { role, text, name, exact, includeHidden, ...rest } = data
+    let options = { ...rest }
+    const accessibleName = name ?? text
+    if (accessibleName !== undefined) options.name = accessibleName
+    if (exact !== undefined) options.exact = exact
+    if (includeHidden !== undefined) options.includeHidden = includeHidden
+    if (Object.keys(options).length === 0) options = undefined
+    return { role, options }
   }
 
+
   /**
    * @returns {boolean}
    */
@@ -404,6 +448,16 @@ Locator.build = locator => {
   return new Locator(locator, 'css')
 }
 
+/**
+ * @param {CodeceptJS.LocatorOrString|Locator} locator
+ * @param {string} [defaultType]
+ * @returns {Locator}
+ */
+Locator.from = (locator, defaultType = '') => {
+  if (locator instanceof Locator) return locator
+  return new Locator(locator, defaultType)
+}
+
 /**
  * Filters to modify locators
  * @type {Array<function(CodeceptJS.LocatorOrString, Locator): void>}
@@ -604,20 +658,10 @@ function removePrefix(xpath) {
  * @param {string} locator
  * @returns {boolean}
  */
-function isPlaywrightLocator(locator) {
+function isReactVueLocator(locator) {
   return locator.includes('_react') || locator.includes('_vue')
 }
 
-/**
- * @private
- * check if the locator is a role locator
- * @param {{role: string}} locator
- * @returns {boolean}
- */
-function isRoleLocator(locator) {
-  return locator.role !== undefined && typeof locator.role === 'string' && Object.keys(locator).length >= 1
-}
-
 /**
  * @private
  * @param {CodeceptJS.LocatorOrString} locator

package/lib/mocha/factory.js

@@ -62,34 +62,9 @@ class MochaFactory {
         const jsFiles = this.files.filter(file => !file.match(/\.feature$/))
         this.files = this.files.filter(file => !file.match(/\.feature$/))
 
-        // Load JavaScript test files using ESM imports
+        // Load JavaScript test files using original loadFiles
         if (jsFiles.length > 0) {
-          try {
-            // Try original loadFiles first for compatibility
-            originalLoadFiles.call(this, fn)
-          } catch (e) {
-            // If original loadFiles fails, load ESM files manually
-            if (e.message.includes('not in cache') || e.message.includes('ESM') || e.message.includes('getStatus')) {
-              // Load ESM files by importing them synchronously using top-level await workaround
-              for (const file of jsFiles) {
-                try {
-                  // Convert file path to file:// URL for dynamic import
-                  const fileUrl = `file://${file}`
-                  // Use import() but don't await it - let it load in the background
-                  import(fileUrl).catch(importErr => {
-                    // If dynamic import fails, the file may have syntax errors or other issues
-                    console.error(`Failed to load test file ${file}:`, importErr.message)
-                  })
-                  if (fn) fn()
-                } catch (fileErr) {
-                  console.error(`Error processing test file ${file}:`, fileErr.message)
-                  if (fn) fn(fileErr)
-                }
-              }
-            } else {
-              throw e
-            }
-          }
+          originalLoadFiles.call(this, fn)
         }
 
         // add ids for each test and check uniqueness

package/lib/step/meta.js

@@ -58,17 +58,24 @@ class MetaStep extends Step {
     this.status = 'queued'
     this.setArguments(Array.from(arguments).slice(1))
     let result
+    let hasChildSteps = false
 
     const registerStep = step => {
       this.setMetaStep(null)
       step.setMetaStep(this)
+      hasChildSteps = true
     }
     event.dispatcher.prependListener(event.step.before, registerStep)
+
+    // Start timing
+    this.startTime = Date.now()
+
     // Handle async and sync methods.
     if (fn.constructor.name === 'AsyncFunction') {
       result = fn
         .apply(this.context, this.args)
         .then(result => {
+          this.setStatus('success')
           return result
         })
         .catch(error => {
@@ -78,17 +85,27 @@ class MetaStep extends Step {
         .finally(() => {
           this.endTime = Date.now()
           event.dispatcher.removeListener(event.step.before, registerStep)
+          // Only emit events if no child steps were registered
+          if (!hasChildSteps) {
+            event.emit(event.step.started, this)
+            event.emit(event.step.finished, this)
+          }
         })
     } else {
       try {
-        this.startTime = Date.now()
         result = fn.apply(this.context, this.args)
+        this.setStatus('success')
       } catch (error) {
         this.setStatus('failed')
         throw error
       } finally {
         this.endTime = Date.now()
         event.dispatcher.removeListener(event.step.before, registerStep)
+        // Only emit events if no child steps were registered
+        if (!hasChildSteps) {
+          event.emit(event.step.started, this)
+          event.emit(event.step.finished, this)
+        }
       }
     }
 

package/lib/utils/loaderCheck.js

@@ -65,9 +65,18 @@ CodeceptJS 4.x uses ES Modules (ESM) and requires a loader to run TypeScript tes
     ✅ Complete: Handles all TypeScript features
 
 ┌─────────────────────────────────────────────────────────────────────────────┐
-│ Option 2: ts-node/esm (Alternative - Established, Requires Config)         │
+│ Option 2: ts-node/esm (Not Recommended - Has Module Resolution Issues)     │
 └─────────────────────────────────────────────────────────────────────────────┘
 
+  ⚠️  ts-node/esm has significant limitations and is not recommended:
+      - Doesn't work with "type": "module" in package.json
+      - Module resolution doesn't work like standard TypeScript ESM
+      - Import statements must use explicit file paths
+  
+  We strongly recommend using tsx/cjs instead.
+  
+  If you still want to use ts-node/esm:
+
   Installation:
     npm install --save-dev ts-node
 
@@ -84,11 +93,12 @@ CodeceptJS 4.x uses ES Modules (ESM) and requires a loader to run TypeScript tes
            "esModuleInterop": true
          },
          "ts-node": {
-           "esm": true,
-           "experimentalSpecifierResolution": "node"
+           "esm": true
          }
        }
 
+    3. Do NOT use "type": "module" in package.json
+
 📚 Documentation: https://codecept.io/typescript
 
 Note: TypeScript config files (codecept.conf.ts) and helpers are automatically

package/lib/utils/typescript.js

@@ -142,8 +142,13 @@ const __dirname = __dirname_fn(__filename);
         }
       }
       
-      // Try adding .ts extension if file doesn't exist and no extension provided
-      if (!path.extname(importedPath)) {
+      // Check for standard module extensions to determine if we should try adding .ts
+      const ext = path.extname(importedPath)
+      const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+      const hasStandardExtension = standardExtensions.includes(ext.toLowerCase())
+      
+      // If it doesn't end with .ts and doesn't have a standard extension, try adding .ts
+      if (!importedPath.endsWith('.ts') && !hasStandardExtension) {
         const tsPath = importedPath + '.ts'
         if (fs.existsSync(tsPath)) {
           importedPath = tsPath
@@ -168,6 +173,7 @@ const __dirname = __dirname_fn(__filename);
       /from\s+['"](\..+?)(?:\.ts)?['"]/g,
       (match, importPath) => {
         let resolvedPath = path.resolve(fileBaseDir, importPath)
+        const originalExt = path.extname(importPath)
         
         // Handle .js extension that might be .ts
         if (resolvedPath.endsWith('.js')) {
@@ -181,6 +187,8 @@ const __dirname = __dirname_fn(__filename);
             }
             return `from '${relPath}'`
           }
+          // Keep .js extension as-is (might be a real .js file)
+          return match
         }
         
         // Try with .ts extension
@@ -197,6 +205,18 @@ const __dirname = __dirname_fn(__filename);
           return `from '${relPath}'`
         }
         
+        // If the import doesn't have a standard module extension (.js, .mjs, .cjs, .json)
+        // add .js for ESM compatibility
+        // This handles cases where:
+        // 1. Import has no real extension (e.g., "./utils" or "./helper")
+        // 2. Import has a non-standard extension that's part of the name (e.g., "./abstract.helper")
+        const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+        const hasStandardExtension = standardExtensions.includes(originalExt.toLowerCase())
+        
+        if (!hasStandardExtension) {
+          return match.replace(importPath, importPath + '.js')
+        }
+        
         // Otherwise, keep the import as-is
         return match
       }

package/lib/workers.js

@@ -5,6 +5,7 @@ import { mkdirp } from 'mkdirp'
 import { Worker } from 'worker_threads'
 import { EventEmitter } from 'events'
 import ms from 'ms'
+import merge from 'lodash.merge'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -66,21 +67,21 @@ const createWorker = (workerObject, isPoolMode = false) => {
     stdout: true,
     stderr: true,
   })
-  
+
   // Pipe worker stdout/stderr to main process
   if (worker.stdout) {
     worker.stdout.setEncoding('utf8')
-    worker.stdout.on('data', (data) => {
+    worker.stdout.on('data', data => {
       process.stdout.write(data)
     })
   }
   if (worker.stderr) {
     worker.stderr.setEncoding('utf8')
-    worker.stderr.on('data', (data) => {
+    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}`)
@@ -221,13 +222,13 @@ 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) => {
+    const cleanConfig = cfg => {
       if (cfg.helpers) {
         cfg.helpers = { ...cfg.helpers }
         Object.keys(cfg.helpers).forEach(helperName => {
@@ -239,14 +240,12 @@ class WorkerObject {
       }
       return cfg
     }
-    
+
     const cleanedOldConfig = cleanConfig(oldConfig)
     const cleanedNewConfig = cleanConfig(configWithoutFunctions)
-    
-    const newConfig = {
-      ...cleanedOldConfig,
-      ...cleanedNewConfig,
-    }
+
+    // Deep merge configurations to preserve all helpers from base config
+    const newConfig = merge({}, cleanedOldConfig, cleanedNewConfig)
     this.options.override = JSON.stringify(newConfig)
   }
 
@@ -280,8 +279,8 @@ class Workers extends EventEmitter {
     this.setMaxListeners(50)
     this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
     this.codecept = null
-    this.config = config  // Save config
-    this.numberOfWorkersRequested = numberOfWorkers  // Save requested worker count
+    this.config = config // Save config
+    this.numberOfWorkersRequested = numberOfWorkers // Save requested worker count
     this.options = config.options || {}
     this.errors = []
     this.numberOfWorkers = 0
@@ -304,11 +303,8 @@ class Workers extends EventEmitter {
       // 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))
-      )
-      
+      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)
       }
@@ -319,7 +315,7 @@ class Workers extends EventEmitter {
     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.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
     this.numberOfWorkers = this.workers.length
   }
 
@@ -371,9 +367,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(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()
@@ -430,7 +426,7 @@ class Workers extends EventEmitter {
     for (const file of files) {
       this.testPool.push(file)
     }
-    
+
     this.testPoolInitialized = true
   }
 
@@ -443,7 +439,7 @@ class Workers extends EventEmitter {
     if (!this.testPoolInitialized) {
       this._initializeTestPool()
     }
-    
+
     return this.testPool.shift()
   }
 
@@ -451,9 +447,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(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()
@@ -494,7 +490,7 @@ class Workers extends EventEmitter {
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
-    
+
     // 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 = []
@@ -503,11 +499,11 @@ class Workers extends EventEmitter {
       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)
     })
@@ -591,7 +587,7 @@ class Workers extends EventEmitter {
           // Otherwise skip - we'll emit based on finished state
           break
         case event.test.passed:
-          // Skip individual passed events - we'll emit based on finished state  
+          // Skip individual passed events - we'll emit based on finished state
           break
         case event.test.skipped:
           this.emit(event.test.skipped, deserializeTest(message.data))
@@ -602,15 +598,15 @@ class Workers extends EventEmitter {
             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
@@ -622,7 +618,7 @@ class Workers extends EventEmitter {
                 this.emit(event.test.passed, deserializeTest(data))
               }
             }
-            
+
             this.emit(event.test.finished, deserializeTest(data))
           }
           break
@@ -682,11 +678,10 @@ class Workers extends EventEmitter {
         // 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)
-        
+        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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.1-beta.2",
+  "version": "4.0.1-beta.21",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -88,17 +88,17 @@
     "@codeceptjs/configure": "1.0.6",
     "@codeceptjs/helper": "2.0.4",
     "@cucumber/cucumber-expressions": "18",
-    "@cucumber/gherkin": "35.1.0",
-    "@cucumber/messages": "29.0.1",
+    "@cucumber/gherkin": "37.0.0",
+    "@cucumber/messages": "31.0.0",
     "@xmldom/xmldom": "0.9.8",
     "acorn": "8.15.0",
     "ai": "^5.0.60",
     "arrify": "3.0.0",
-    "axios": "1.12.2",
+    "axios": "1.13.2",
     "chalk": "4.1.2",
     "cheerio": "^1.0.0",
     "chokidar": "^4.0.3",
-    "commander": "11.1.0",
+    "commander": "14.0.2",
     "cross-spawn": "7.0.6",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
@@ -108,11 +108,11 @@
     "fn-args": "4.0.0",
     "fs-extra": "11.3.2",
     "fuse.js": "^7.0.0",
-    "glob": ">=9.0.0 <12",
+    "glob": ">=9.0.0 <14",
     "html-minifier-terser": "7.2.0",
     "inquirer": "^8.2.7",
     "invisi-data": "^1.0.0",
-    "joi": "18.0.1",
+    "joi": "18.0.2",
     "js-beautify": "1.15.4",
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
@@ -144,16 +144,16 @@
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "6.0.6",
     "@testomatio/reporter": "^2.3.1",
-    "@types/chai": "5.2.2",
+    "@types/chai": "5.2.3",
     "@types/inquirer": "9.0.9",
     "@types/node": "^24.9.2",
     "@wdio/sauce-service": "9.12.5",
     "@wdio/selenium-standalone-service": "8.15.0",
-    "@wdio/utils": "9.20.0",
+    "@wdio/utils": "9.21.0",
     "@xmldom/xmldom": "0.9.8",
     "bunosh": "latest",
-    "chai": "^4.5.0",
-    "chai-as-promised": "7.1.2",
+    "chai": "^6.2.1",
+    "chai-as-promised": "^8.0.2",
     "chai-subset": "1.6.0",
     "documentation": "14.0.3",
     "electron": "38.2.0",
@@ -162,8 +162,8 @@
     "eslint-plugin-mocha": "11.1.0",
     "expect": "30.2.0",
     "express": "^5.1.0",
-    "globals": "16.4.0",
-    "graphql": "16.11.0",
+    "globals": "16.5.0",
+    "graphql": "16.12.0",
     "graphql-tag": "^2.12.6",
     "husky": "9.1.7",
     "jsdoc": "^3.6.11",
@@ -172,19 +172,19 @@
     "mochawesome": "^7.1.3",
     "playwright": "1.55.1",
     "prettier": "^3.3.2",
-    "puppeteer": "24.15.0",
+    "puppeteer": "24.33.0",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
     "runok": "^0.9.3",
     "semver": "7.7.3",
     "sinon": "21.0.0",
-    "sinon-chai": "3.7.0",
+    "sinon-chai": "^4.0.1",
     "ts-morph": "27.0.2",
     "ts-node": "10.9.2",
     "tsd": "^0.33.0",
     "tsd-jsdoc": "2.5.0",
     "tsx": "^4.19.2",
-    "typedoc": "0.28.13",
+    "typedoc": "0.28.15",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.8.3",
     "wdio-docker-service": "3.2.1",