codeceptjs 4.0.0-beta.5 → 4.0.0-beta.6.esm-aria

package/lib/container.js

@@ -1,16 +1,18 @@
-const { globSync } = require('glob')
-const path = require('path')
-const debug = require('debug')('codeceptjs:container')
-const { MetaStep } = require('./step')
-const { methodsOfObject, fileExists, isFunction, isAsyncFunction, installedLocally } = require('./utils')
-const Translation = require('./translation')
-const MochaFactory = require('./mocha/factory')
-const recorder = require('./recorder')
-const event = require('./event')
-const WorkerStorage = require('./workerStorage')
-const store = require('./store')
-const Result = require('./result')
-const ai = require('./ai')
+import { globSync } from 'glob'
+import path from 'path'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:container')
+import { MetaStep } from './step.js'
+import { methodsOfObject, fileExists, isFunction, isAsyncFunction, installedLocally, deepMerge } from './utils.js'
+import Translation from './translation.js'
+import MochaFactory from './mocha/factory.js'
+import recorder from './recorder.js'
+import event from './event.js'
+import WorkerStorage from './workerStorage.js'
+import store from './store.js'
+import Result from './result.js'
+import ai from './ai.js'
+import actorFactory from './actor.js'
 
 let asyncHelperPromise
 
@@ -28,7 +30,6 @@ let container = {
   translation: {},
   /** @type {Result | null} */
   result: null,
-  sharedKeys: new Set() // Track keys shared via share() function
 }
 
 /**
@@ -40,7 +41,7 @@ class Container {
    *
    */
   static get STANDARD_ACTING_HELPERS() {
-    return ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'TestCafe']
+    return ['Playwright', 'WebDriver', 'Puppeteer', 'Appium']
   }
   /**
    * Create container with all required helpers and support objects
@@ -49,7 +50,7 @@ class Container {
    * @param {*} config
    * @param {*} opts
    */
-  static create(config, opts) {
+  static async create(config, opts) {
     debug('creating container')
     asyncHelperPromise = Promise.resolve()
 
@@ -61,16 +62,53 @@ class Container {
 
     // create support objects
     container.support = {}
-    container.helpers = createHelpers(config.helpers || {})
-    container.translation = loadTranslation(config.translation || null, config.vocabularies || [])
+    container.helpers = await createHelpers(config.helpers || {})
+    container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
     container.proxySupport = createSupportObjects(config.include || {})
-    container.plugins = createPlugins(config.plugins || {}, opts)
+    container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
-    createActor(config.include?.I)
+    // Preload includes (so proxies can expose real objects synchronously)
+    const includes = config.include || {}
+
+    // Ensure I is available for DI modules at import time
+    if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
+      try {
+        const mod = includes.I
+        if (typeof mod === 'string') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (typeof mod === 'function') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (mod && typeof mod === 'object') {
+          container.support.I = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object I: ${e.message}`)
+      }
+    } else {
+      // Create default actor if not provided via includes
+      createActor()
+    }
+
+    // Load remaining includes except I
+    for (const [name, mod] of Object.entries(includes)) {
+      if (name === 'I') continue
+      try {
+        if (typeof mod === 'string') {
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (typeof mod === 'function') {
+          // function or class
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (mod && typeof mod === 'object') {
+          container.support[name] = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object ${name}: ${e.message}`)
+      }
+    }
 
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
-    if (config.gherkin) loadGherkinSteps(config.gherkin.steps || [])
+    if (config.gherkin) await loadGherkinStepsAsync(config.gherkin.steps || [])
     if (opts && typeof opts.timeouts === 'boolean') store.timeouts = opts.timeouts
   }
 
@@ -103,7 +141,8 @@ class Container {
     if (!name) {
       return container.proxySupport
     }
-    return container.support[name] || container.proxySupport[name]
+    // Always return the proxy to ensure MetaStep creation works
+    return container.proxySupport[name]
   }
 
   /**
@@ -158,8 +197,14 @@ class Container {
    * @param {Object<string, *>} newContainer
    */
   static append(newContainer) {
-    const deepMerge = require('./utils').deepMerge
     container = deepMerge(container, newContainer)
+
+    // If new support objects are added, update the proxy support
+    if (newContainer.support) {
+      const newProxySupport = createSupportObjects(newContainer.support)
+      container.proxySupport = { ...container.proxySupport, ...newProxySupport }
+    }
+
     debug('appended', JSON.stringify(newContainer).slice(0, 300))
   }
 
@@ -170,12 +215,11 @@ class Container {
    * @param {Object<string, *>} newSupport
    * @param {Object<string, *>} newPlugins
    */
-  static clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
+  static async clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
     container.helpers = newHelpers
-    container.translation = loadTranslation()
+    container.translation = await loadTranslation()
     container.proxySupport = createSupportObjects(newSupport)
     container.plugins = newPlugins
-    container.sharedKeys = new Set() // Clear shared keys
     asyncHelperPromise = Promise.resolve()
     store.actor = null
     debug('container cleared')
@@ -199,13 +243,7 @@ class Container {
    * @param {Object} options - set {local: true} to not share among workers
    */
   static share(data, options = {}) {
-    // Instead of using append which replaces the entire container,
-    // directly update the support object to maintain proxy references
-    Object.assign(container.support, data)
-    
-    // Track which keys were explicitly shared
-    Object.keys(data).forEach(key => container.sharedKeys.add(key))
-    
+    Container.append({ support: data })
     if (!options.local) {
       WorkerStorage.share(data)
     }
@@ -220,23 +258,56 @@ class Container {
   }
 }
 
-module.exports = Container
+export default Container
 
-function createHelpers(config) {
+async function createHelpers(config) {
   const helpers = {}
   for (let helperName in config) {
     try {
       let HelperClass
 
-      // ESM import
-      if (helperName?.constructor === Function && helperName.prototype) {
+      // Check if helper class was stored in config during ESM import processing
+      if (config[helperName]._helperClass) {
+        HelperClass = config[helperName]._helperClass
+        debug(`helper ${helperName} loaded from ESM import`)
+      }
+
+      // ESM import (legacy check)
+      if (!HelperClass && typeof helperName === 'function' && helperName.prototype) {
         HelperClass = helperName
         helperName = HelperClass.constructor.name
       }
 
-      // classical require
+      // classical require - may be async for ESM modules
       if (!HelperClass) {
-        HelperClass = requireHelperFromModule(helperName, config)
+        const helperResult = requireHelperFromModule(helperName, config)
+        if (helperResult instanceof Promise) {
+          // Handle async ESM loading
+          helpers[helperName] = {}
+          asyncHelperPromise = asyncHelperPromise
+            .then(() => helperResult)
+            .then(async ResolvedHelperClass => {
+              debug(`helper ${helperName} resolved type: ${typeof ResolvedHelperClass}`, ResolvedHelperClass)
+
+              // Extract default export from ESM module wrapper if needed
+              if (ResolvedHelperClass && ResolvedHelperClass.__esModule && ResolvedHelperClass.default) {
+                ResolvedHelperClass = ResolvedHelperClass.default
+                debug(`extracted default export for ${helperName}, new type: ${typeof ResolvedHelperClass}`)
+              }
+
+              if (typeof ResolvedHelperClass !== 'function') {
+                throw new Error(`Helper '${helperName}' is not a class. Got: ${typeof ResolvedHelperClass}`)
+              }
+
+              checkHelperRequirements(ResolvedHelperClass)
+              helpers[helperName] = new ResolvedHelperClass(config[helperName])
+              if (helpers[helperName]._init) await helpers[helperName]._init()
+              debug(`helper ${helperName} async initialized`)
+            })
+          continue
+        } else {
+          HelperClass = helperResult
+        }
       }
 
       // handle async CJS modules that use dynamic import
@@ -269,7 +340,7 @@ function createHelpers(config) {
   }
 
   for (const name in helpers) {
-    if (helpers[name]._init) helpers[name]._init()
+    if (helpers[name]._init) await helpers[name]._init()
   }
   return helpers
 }
@@ -290,23 +361,43 @@ function checkHelperRequirements(HelperClass) {
   }
 }
 
-function requireHelperFromModule(helperName, config, HelperClass) {
+async function requireHelperFromModule(helperName, config, HelperClass) {
   const moduleName = getHelperModuleName(helperName, config)
   if (moduleName.startsWith('./helper/')) {
-    HelperClass = require(moduleName)
+    try {
+      // For built-in helpers, use direct relative import with .js extension
+      const helperPath = `${moduleName}.js`
+      const mod = await import(helperPath)
+      HelperClass = mod.default || mod
+    } catch (err) {
+      throw err
+    }
   } else {
     // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
     try {
-      const mod = require(moduleName)
+      // Try dynamic import for both CommonJS and ESM modules
+      const mod = await import(moduleName)
       if (!mod && !mod.default) {
         throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
       }
       HelperClass = mod.default || mod
     } catch (err) {
-      if (err.code === 'MODULE_NOT_FOUND') {
+      if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
+        // This is an ESM module, use dynamic import
+        try {
+          const pathModule = await import('path')
+          const absolutePath = pathModule.default.resolve(moduleName)
+          const mod = await import(absolutePath)
+          HelperClass = mod.default || mod
+          debug(`helper ${helperName} loaded via ESM import`)
+        } catch (importErr) {
+          throw new Error(`Helper module '${moduleName}' could not be imported as ESM: ${importErr.message}`)
+        }
+      } else if (err.code === 'MODULE_NOT_FOUND') {
         throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
+      } else {
+        throw err
       }
-      throw err
     }
   }
   return HelperClass
@@ -338,14 +429,21 @@ function createSupportObjects(config) {
           }
 
           // load actual name from vocabulary
-          if (container.translation.name) {
-            name = container.translation.name
+          if (container.translation && container.translation.I && name === 'I') {
+            // Use translated name for I
+            const actualName = container.translation.I
+            if (actualName !== 'I') {
+              name = actualName
+            }
           }
 
           if (name === 'I') {
-            const actor = createActor(config.I)
-            methodsOfObject(actor)
-            return actor[prop]
+            if (!container.support.I) {
+              // Actor will be created during container.create()
+              return undefined
+            }
+            methodsOfObject(container.support.I)
+            return container.support.I[prop]
           }
 
           if (!container.support[name] && typeof config[name] === 'object') {
@@ -353,17 +451,10 @@ function createSupportObjects(config) {
           }
 
           if (!container.support[name]) {
-            // Load object on first access
-            const supportObject = loadSupportObject(config[name])
-            container.support[name] = supportObject
-            try {
-              if (container.support[name]._init) {
-                container.support[name]._init()
-              }
-              debug(`support object ${name} initialized`)
-            } catch (err) {
-              throw new Error(`Initialization failed for ${name}: ${container.support[name]}\n${err.message}\n${err.stack}`)
-            }
+            // Cannot load object synchronously in proxy getter
+            // Return undefined and log warning - object should be pre-loaded during container creation
+            debug(`Support object ${name} not pre-loaded, returning undefined`)
+            return undefined
           }
 
           const currentObject = container.support[name]
@@ -380,19 +471,32 @@ function createSupportObjects(config) {
           return currentValue
         },
         has(target, prop) {
-          container.support[name] = container.support[name] || loadSupportObject(config[name])
+          if (!container.support[name]) {
+            // Note: This is sync, so we can't use async loadSupportObject here
+            // The object will be loaded lazily on first property access
+            return false
+          }
           return prop in container.support[name]
         },
         getOwnPropertyDescriptor(target, prop) {
-          container.support[name] = container.support[name] || loadSupportObject(config[name])
+          if (!container.support[name]) {
+            // Object will be loaded on property access
+            return {
+              enumerable: true,
+              configurable: true,
+              value: undefined,
+            }
+          }
           return {
             enumerable: true,
             configurable: true,
-            value: this.get(target, prop),
+            value: container.support[name][prop],
           }
         },
         ownKeys() {
-          container.support[name] = container.support[name] || loadSupportObject(config[name])
+          if (!container.support[name]) {
+            return []
+          }
           return Reflect.ownKeys(container.support[name])
         },
       },
@@ -404,23 +508,29 @@ function createSupportObjects(config) {
     {},
     {
       has(target, key) {
-        return keys.includes(key) || container.sharedKeys.has(key)
+        return keys.includes(key)
       },
       ownKeys() {
-        // Return both original config keys and explicitly shared keys
-        return [...new Set([...keys, ...container.sharedKeys])]
+        return keys
       },
       getOwnPropertyDescriptor(target, prop) {
         return {
           enumerable: true,
           configurable: true,
-          value: this.get(target, prop),
+          value: target[prop],
         }
       },
       get(target, key) {
-        // First check if this is an explicitly shared property
-        if (container.sharedKeys.has(key) && key in container.support) {
-          return container.support[key]
+        if (typeof key === 'symbol') {
+          // safely ignore symbol-based meta properties used by tooling
+          return undefined
+        }
+        // Allow special I even if not declared in includes
+        if (key === 'I') {
+          return lazyLoad('I')
+        }
+        if (!keys.includes(key)) {
+          throw new Error(`Support object "${String(key)}" is not defined`)
         }
         return lazyLoad(key)
       },
@@ -431,17 +541,35 @@ function createSupportObjects(config) {
 function createActor(actorPath) {
   if (container.support.I) return container.support.I
 
-  if (actorPath) {
-    container.support.I = loadSupportObject(actorPath)
-  } else {
-    const actor = require('./actor')
-    container.support.I = actor()
-  }
+  // Default actor
+  container.support.I = actorFactory({}, Container)
 
   return container.support.I
 }
 
-function createPlugins(config, options = {}) {
+async function loadPluginAsync(modulePath, config) {
+  let pluginMod
+  try {
+    // Try dynamic import first (works for both ESM and CJS)
+    pluginMod = await import(modulePath)
+  } catch (err) {
+    throw new Error(`Could not load plugin from '${modulePath}': ${err.message}`)
+  }
+
+  const pluginFactory = pluginMod.default || pluginMod
+  if (typeof pluginFactory !== 'function') {
+    throw new Error(`Plugin '${modulePath}' is not a function. Expected a plugin factory function.`)
+  }
+
+  return pluginFactory(config)
+}
+
+async function loadPluginFallback(modulePath, config) {
+  // This function is kept for backwards compatibility but now uses dynamic import
+  return await loadPluginAsync(modulePath, config)
+}
+
+async function createPlugins(config, options = {}) {
   const plugins = {}
 
   const enabledPluginsByOptions = (options.plugins || '').split(',')
@@ -459,9 +587,12 @@ function createPlugins(config, options = {}) {
           module = path.resolve(global.codecept_dir, module) // custom plugin
         }
       } else {
-        module = `./plugin/${pluginName}`
+        module = `./plugin/${pluginName}.js`
       }
-      plugins[pluginName] = require(module)(config[pluginName])
+
+      // Use async loading for all plugins (ESM and CJS)
+      plugins[pluginName] = await loadPluginAsync(module, config[pluginName])
+      debug(`plugin ${pluginName} loaded via async import`)
     } catch (err) {
       throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`)
     }
@@ -469,24 +600,34 @@ function createPlugins(config, options = {}) {
   return plugins
 }
 
-function loadGherkinSteps(paths) {
+async function loadGherkinStepsAsync(paths) {
   global.Before = fn => event.dispatcher.on(event.test.started, fn)
   global.After = fn => event.dispatcher.on(event.test.finished, fn)
   global.Fail = fn => event.dispatcher.on(event.test.failed, fn)
 
+  // Import BDD module to access step file tracking functions
+  const bddModule = await import('./mocha/bdd.js')
+
   // If gherkin.steps is string, then this will iterate through that folder and send all step def js files to loadSupportObject
   // If gherkin.steps is Array, it will go the old way
   // This is done so that we need not enter all Step Definition files under config.gherkin.steps
   if (Array.isArray(paths)) {
     for (const path of paths) {
-      loadSupportObject(path, `Step Definition from ${path}`)
+      // Set context for step definition file location tracking
+      bddModule.setCurrentStepFile(path)
+      await loadSupportObject(path, `Step Definition from ${path}`)
+      bddModule.clearCurrentStepFile()
     }
   } else {
     const folderPath = paths.startsWith('.') ? normalizeAndJoin(global.codecept_dir, paths) : ''
     if (folderPath !== '') {
-      globSync(folderPath).forEach(file => {
-        loadSupportObject(file, `Step Definition from ${file}`)
-      })
+      const files = globSync(folderPath)
+      for (const file of files) {
+        // Set context for step definition file location tracking
+        bddModule.setCurrentStepFile(file)
+        await loadSupportObject(file, `Step Definition from ${file}`)
+        bddModule.clearCurrentStepFile()
+      }
     }
   }
 
@@ -495,47 +636,97 @@ function loadGherkinSteps(paths) {
   delete global.Fail
 }
 
-function loadSupportObject(modulePath, supportObjectName) {
+function loadGherkinSteps(paths) {
+  global.Before = fn => event.dispatcher.on(event.test.started, fn)
+  global.After = fn => event.dispatcher.on(event.test.finished, fn)
+  global.Fail = fn => event.dispatcher.on(event.test.failed, fn)
+
+  // Gherkin step loading must be handled asynchronously
+  throw new Error('Gherkin step loading must be converted to async. Use loadGherkinStepsAsync() instead.')
+
+  delete global.Before
+  delete global.After
+  delete global.Fail
+}
+
+async function loadSupportObject(modulePath, supportObjectName) {
   if (!modulePath) {
     throw new Error(`Support object "${supportObjectName}" is not defined`)
   }
-  if (modulePath.charAt(0) === '.') {
+  // If function/class provided directly
+  if (typeof modulePath === 'function') {
+    try {
+      // class constructor
+      if (modulePath.prototype && modulePath.prototype.constructor === modulePath) {
+        return new modulePath()
+      }
+      // plain function factory
+      return modulePath()
+    } catch (err) {
+      throw new Error(`Could not include object ${supportObjectName} from function: ${err.message}`)
+    }
+  }
+  if (typeof modulePath === 'string' && modulePath.charAt(0) === '.') {
     modulePath = path.join(global.codecept_dir, modulePath)
   }
   try {
-    const obj = require(modulePath)
+    // Use dynamic import for both ESM and CJS modules
+    let importPath = modulePath
+    // Append .js if no extension provided (ESM resolution requires it)
+    if (typeof importPath === 'string') {
+      const ext = path.extname(importPath)
+      if (!ext) importPath = `${importPath}.js`
+    }
+    const obj = await import(importPath)
+
+    // Handle ESM module wrapper
+    let actualObj = obj
+    if (obj && obj.__esModule && obj.default) {
+      actualObj = obj.default
+    } else if (obj.default) {
+      actualObj = obj.default
+    }
 
     // Handle different types of imports
-    if (typeof obj === 'function') {
+    if (typeof actualObj === 'function') {
       // If it's a class (constructor function)
-      if (obj.prototype && obj.prototype.constructor === obj) {
-        const ClassName = obj
+      if (actualObj.prototype && actualObj.prototype.constructor === actualObj) {
+        const ClassName = actualObj
         return new ClassName()
       }
       // If it's a regular function
-      return obj()
+      return actualObj()
     }
 
-    if (obj && Array.isArray(obj)) {
-      return obj
+    if (actualObj && Array.isArray(actualObj)) {
+      return actualObj
     }
 
     // If it's a plain object
-    if (obj && typeof obj === 'object') {
-      return obj
+    if (actualObj && typeof actualObj === 'object') {
+      // Call _init if it exists (for page objects)
+      if (actualObj._init && typeof actualObj._init === 'function') {
+        actualObj._init()
+      }
+      return actualObj
     }
 
-    throw new Error(`Support object "${supportObjectName}" should be an object, class, or function, but got ${typeof obj}`)
+    throw new Error(`Support object "${supportObjectName}" should be an object, class, or function, but got ${typeof actualObj}`)
   } catch (err) {
     throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}\n${err.stack}`)
   }
 }
 
+// Backwards compatibility function that throws an error for sync usage
+function loadSupportObjectSync(modulePath, supportObjectName) {
+  throw new Error(`loadSupportObjectSync is deprecated. Support object "${supportObjectName || 'undefined'}" from '${modulePath}' must be loaded asynchronously. Use loadSupportObject() instead.`)
+}
+
 /**
  * Method collect own property and prototype
  */
 
-function loadTranslation(locale, vocabularies) {
+async function loadTranslation(locale, vocabularies) {
   if (!locale) {
     return Translation.createEmpty()
   }
@@ -543,8 +734,9 @@ function loadTranslation(locale, vocabularies) {
   let translation
 
   // check if it is a known translation
-  if (Translation.langs[locale]) {
-    translation = new Translation(Translation.langs[locale])
+  const langs = await Translation.getLangs()
+  if (langs[locale]) {
+    translation = new Translation(langs[locale])
   } else if (fileExists(path.join(global.codecept_dir, locale))) {
     // get from a provided file instead
     translation = Translation.createDefault()
@@ -562,7 +754,12 @@ function getHelperModuleName(helperName, config) {
   // classical require
   if (config[helperName].require) {
     if (config[helperName].require.startsWith('.')) {
-      return path.resolve(global.codecept_dir, config[helperName].require) // custom helper
+      let helperPath = path.resolve(global.codecept_dir, config[helperName].require)
+      // Add .js extension if not present for ESM compatibility
+      if (!path.extname(helperPath)) {
+        helperPath += '.js'
+      }
+      return helperPath // custom helper
     }
     return config[helperName].require // plugin helper
   }

package/lib/data/context.js

@@ -1,9 +1,10 @@
-const { isGenerator } = require('../utils')
-const DataTable = require('./table')
-const DataScenarioConfig = require('./dataScenarioConfig')
-const Secret = require('../secret')
+import { isGenerator } from '../utils.js'
+import DataTable from './table.js'
+import DataScenarioConfig from './dataScenarioConfig.js'
+import secretModule from '../secret.js'
+const Secret = secretModule.default || secretModule
 
-module.exports = function (context) {
+export default function (context) {
   context.Data = function (dataTable) {
     const data = detectDataType(dataTable)
     return {

package/lib/data/dataScenarioConfig.js

@@ -81,4 +81,4 @@ class DataScenarioConfig {
   }
 }
 
-module.exports = DataScenarioConfig
+export default DataScenarioConfig

package/lib/data/dataTableArgument.js

@@ -63,4 +63,4 @@ class DataTableArgument {
   }
 }
 
-module.exports = DataTableArgument
+export default DataTableArgument