codeceptjs 4.0.0-beta.20 → 4.0.0-beta.21

package/lib/actor.js

@@ -7,6 +7,8 @@ import event from './event.js'
 import store from './store.js'
 import output from './output.js'
 import Container from './container.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:actor')
 
 /**
  * @interface

package/lib/container.js

@@ -17,6 +17,51 @@ import ai from './ai.js'
 import actorFactory from './actor.js'
 
 let asyncHelperPromise
+let tsxLoaderRegistered = false
+
+/**
+ * Automatically register tsx ESM loader for TypeScript imports
+ * This allows loading .ts files without NODE_OPTIONS
+ */
+async function ensureTsxLoader() {
+  if (tsxLoaderRegistered) return true
+
+  try {
+    // Check if tsx is available
+    const { createRequire } = await import('module')
+    const { pathToFileURL } = await import('url')
+    const userRequire = createRequire(pathToFileURL(path.join(global.codecept_dir || process.cwd(), 'package.json')).href)
+    
+    // Try to resolve tsx from user's project
+    try {
+      userRequire.resolve('tsx')
+    } catch {
+      debug('tsx not found in user project')
+      return false
+    }
+
+    // Register tsx/esm loader dynamically
+    // Use Node.js register() API from node:module (Node 18.19+, 20.6+)
+    try {
+      const { register } = await import('node:module')
+      if (typeof register === 'function') {
+        debug('Registering tsx ESM loader via node:module register()')
+        const tsxPath = userRequire.resolve('tsx/esm')
+        register(tsxPath, import.meta.url)
+        tsxLoaderRegistered = true
+        return true
+      }
+    } catch (registerErr) {
+      debug('node:module register() not available:', registerErr.message)
+    }
+
+    debug('module.register not available, tsx loader must be set via NODE_OPTIONS')
+    return false
+  } catch (err) {
+    debug('Failed to register tsx loader:', err.message)
+    return false
+  }
+}
 
 let container = {
   helpers: {},
@@ -349,6 +394,9 @@ async function createHelpers(config) {
     }
   }
 
+  // Wait for all async helpers to be resolved before calling _init
+  await asyncHelperPromise
+  
   for (const name in helpers) {
     if (helpers[name]._init) await helpers[name]._init()
   }
@@ -392,7 +440,83 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       }
       HelperClass = mod.default || mod
     } catch (err) {
-      if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
+      if (err.code === 'ERR_UNKNOWN_FILE_EXTENSION' || (err.message && err.message.includes('Unknown file extension'))) {
+          // This is likely a TypeScript helper file. Transpile it to a temporary JS file
+          // and import that as a reliable fallback (no NODE_OPTIONS required).
+          try {
+            const pathModule = await import('path')
+            const absolutePath = pathModule.default.resolve(moduleName)
+
+            // Attempt to load local 'typescript' to transpile the helper
+            let typescript
+            try {
+              typescript = await import('typescript')
+            } catch (tsImportErr) {
+              throw new Error(`TypeScript helper detected (${moduleName}). Please install 'typescript' in your project: npm install --save-dev typescript`)
+            }
+
+            const { tempFile, allTempFiles } = await transpileTypeScript(absolutePath, typescript)
+            debug(`Transpiled TypeScript helper: ${moduleName} -> ${tempFile}`)
+
+            try {
+              try {
+                const mod = await import(tempFile)
+                HelperClass = mod.default || mod
+                debug(`helper ${helperName} loaded from transpiled JS: ${tempFile}`)
+              } catch (importTempErr) {
+                // If import fails due to CommonJS named export incompatibility,
+                // try a quick transform: convert named imports from CommonJS packages
+                // into default import + destructuring. This resolves cases like
+                // "Named export 'Helper' not found. The requested module '@codeceptjs/helper' is a CommonJS module"
+                const msg = importTempErr && importTempErr.message || ''
+                const commonJsMatch = msg.match(/The requested module '(.+?)' is a CommonJS module/)
+                if (commonJsMatch) {
+                  // Read the transpiled file, perform heuristic replacement, and import again
+                  const fs = await import('fs')
+                  let content = fs.readFileSync(tempFile, 'utf8')
+                  // Heuristic: replace "import { X, Y } from 'mod'" with default import + destructure
+                  content = content.replace(/import\s+\{([^}]+)\}\s+from\s+(['"])([^'"\)]+)\2/gm, (m, names, q, modName) => {
+                    // Only adjust imports for the module reported in the error or for local modules
+                    if (modName === commonJsMatch[1] || modName.startsWith('.') || !modName.includes('/')) {
+                      const cleanedNames = names.trim()
+                      return `import pkg__interop from ${q}${modName}${q};\nconst { ${cleanedNames} } = pkg__interop`
+                    }
+                    return m
+                  })
+
+                  // Write to a secondary temp file
+                  const os = await import('os')
+                  const path = await import('path')
+                  const fallbackTemp = path.default.join(os.default.tmpdir(), `helper-fallback-${Date.now()}.mjs`)
+                  fs.writeFileSync(fallbackTemp, content, 'utf8')
+                  try {
+                    const mod = await import(fallbackTemp)
+                    HelperClass = mod.default || mod
+                    debug(`helper ${helperName} loaded from transpiled JS after CommonJS interop fix: ${fallbackTemp}`)
+                  } finally {
+                    try { fs.unlinkSync(fallbackTemp) } catch (e) {}
+                  }
+                } else {
+                  throw importTempErr
+                }
+              }
+            } finally {
+              // Cleanup transpiled temporary files
+              const filesToClean = Array.isArray(allTempFiles) ? allTempFiles : [allTempFiles]
+              cleanupTempFiles(filesToClean)
+            }
+          } catch (importErr) {
+            throw new Error(
+              `Helper '${helperName}' is a TypeScript file but could not be loaded.\n` +
+              `Path: ${moduleName}\n` +
+              `Error: ${importErr.message}\n\n` +
+              `To load TypeScript helpers, install 'typescript' in your project or use an ESM loader (e.g. tsx):\n` +
+              `  npm install --save-dev typescript\n` +
+              `  OR run CodeceptJS with an ESM loader: NODE_OPTIONS='--import tsx' npx codeceptjs run\n\n` +
+              `CodeceptJS will transpile TypeScript helpers automatically at runtime if 'typescript' is available.`
+            )
+          }
+      } else 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')

package/lib/parser.js

@@ -17,7 +17,14 @@ export const getParamsToString = function (fn) {
 function getParams(fn) {
   if (fn.isSinonProxy) return []
   try {
-    const reflected = parser.parse(fn)
+    // Convert arrow functions to regular functions for parsing
+    let fnString = fn.toString()
+    // Handle async arrow functions: async (...) => { becomes async function(...) {
+    fnString = fnString.replace(/^async\s*(\([^)]*\))\s*=>/, 'async function$1')
+    // Handle regular arrow functions: (...) => { becomes function(...) {
+    fnString = fnString.replace(/^(\([^)]*\))\s*=>/, 'function$1')
+    
+    const reflected = parser.parse(fnString)
     if (reflected.args.length > 1 || reflected.args[0] === 'I') {
       output.error('Error: old CodeceptJS v2 format detected. Upgrade your project to the new format -> https://bit.ly/codecept3Up')
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-beta.20",
+  "version": "4.0.0-beta.21",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [