codeceptjs 4.0.0-beta.9.esm-aria → 4.0.1-beta.1

package/lib/codecept.js

@@ -3,8 +3,9 @@ import { globSync } from 'glob'
 import shuffle from 'lodash.shuffle'
 import fsPath from 'path'
 import { resolve } from 'path'
-import { fileURLToPath } from 'url'
+import { fileURLToPath, pathToFileURL } from 'url'
 import { dirname } from 'path'
+import { createRequire } from 'module'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -18,6 +19,7 @@ import ActorFactory from './actor.js'
 import output from './output.js'
 import { emptyFolder } from './utils.js'
 import { initCodeceptGlobals } from './globals.js'
+import { validateTypeScriptSetup } from './utils/loaderCheck.js'
 import recorder from './recorder.js'
 
 import storeListener from './listener/store.js'
@@ -66,6 +68,21 @@ class Codecept {
               modulePath = `${modulePath}.js`
             }
           }
+        } else {
+          // For npm packages, resolve from the user's directory
+          // This ensures packages like tsx are found in user's node_modules
+          const userDir = global.codecept_dir || process.cwd()
+          
+          try {
+            // Use createRequire to resolve from user's directory
+            const userRequire = createRequire(pathToFileURL(resolve(userDir, 'package.json')).href)
+            const resolvedPath = userRequire.resolve(requiredModule)
+            modulePath = pathToFileURL(resolvedPath).href
+          } catch (resolveError) {
+            // If resolution fails, try direct import (will check from CodeceptJS node_modules)
+            // This is the fallback for globally installed packages
+            modulePath = requiredModule
+          }
         }
         // Use dynamic import for ESM
         await import(modulePath)
@@ -246,6 +263,13 @@ class Codecept {
   async run(test) {
     await container.started()
 
+    // Check TypeScript loader configuration before running tests
+    const tsValidation = validateTypeScriptSetup(this.testFiles, this.requiringModules || [])
+    if (tsValidation.hasError) {
+      output.error(tsValidation.message)
+      process.exit(1)
+    }
+
     // Ensure translations are loaded for Gherkin features
     try {
       const { loadTranslations } = await import('./mocha/gherkin.js')

package/lib/command/init.js

@@ -161,7 +161,7 @@ export default async function (initPath) {
         isTypeScript = true
         extension = isTypeScript === true ? 'ts' : 'js'
         packages.push('typescript')
-        packages.push('ts-node')
+        packages.push('tsx')  // Add tsx for TypeScript support
         packages.push('@types/node')
       }
 
@@ -172,6 +172,7 @@ export default async function (initPath) {
       config.tests = result.tests
       if (isTypeScript) {
         config.tests = `${config.tests.replace(/\.js$/, `.${extension}`)}`
+        config.require = ['tsx/cjs']  // Add tsx/cjs loader for TypeScript tests
       }
 
       // create a directory tests if it is included in tests path

package/lib/config.js

@@ -2,6 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import { createRequire } from 'module'
 import { fileExists, isFile, deepMerge, deepClone } from './utils.js'
+import { transpileTypeScript, cleanupTempFiles } from './utils/typescript.js'
 
 const defaultConfig = {
   output: './_output',
@@ -156,31 +157,15 @@ async function loadConfigFile(configFile) {
       // For .ts files, try to compile and load as JavaScript
       if (extensionName === '.ts') {
         try {
-          // Try to load ts-node and compile the file
-          const { transpile } = require('typescript')
-          const tsContent = fs.readFileSync(configFile, 'utf8')
-
-          // Transpile TypeScript to JavaScript with ES module output
-          const jsContent = transpile(tsContent, {
-            module: 99, // ModuleKind.ESNext
-            target: 99, // ScriptTarget.ESNext
-            esModuleInterop: true,
-            allowSyntheticDefaultImports: true,
-          })
-
-          // Create a temporary JS file with .mjs extension to force ES module treatment
-          const tempJsFile = configFile.replace('.ts', '.temp.mjs')
-          fs.writeFileSync(tempJsFile, jsContent)
+          // Use the TypeScript transpilation utility
+          const typescript = require('typescript')
+          const { tempFile, allTempFiles } = await transpileTypeScript(configFile, typescript)
 
           try {
-            configModule = await import(tempJsFile)
-            // Clean up temp file
-            fs.unlinkSync(tempJsFile)
+            configModule = await import(tempFile)
+            cleanupTempFiles(allTempFiles)
           } catch (err) {
-            // Clean up temp file even on error
-            if (fs.existsSync(tempJsFile)) {
-              fs.unlinkSync(tempJsFile)
-            }
+            cleanupTempFiles(allTempFiles)
             throw err
           }
         } catch (tsError) {

package/lib/container.js

@@ -1,9 +1,11 @@
 import { globSync } from 'glob'
 import path from 'path'
+import fs from 'fs'
 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 { transpileTypeScript, cleanupTempFiles } from './utils/typescript.js'
 import Translation from './translation.js'
 import MochaFactory from './mocha/factory.js'
 import recorder from './recorder.js'
@@ -30,7 +32,7 @@ let container = {
   translation: {},
   /** @type {Result | null} */
   result: null,
-  sharedKeys: new Set() // Track keys shared via share() function
+  sharedKeys: new Set(), // Track keys shared via share() function
 }
 
 /**
@@ -200,6 +202,15 @@ class Container {
   static append(newContainer) {
     container = deepMerge(container, newContainer)
 
+    // If new helpers are added, set the helpers property on them
+    if (newContainer.helpers) {
+      for (const name in newContainer.helpers) {
+        if (container.helpers[name] && typeof container.helpers[name] === 'object') {
+          container.helpers[name].helpers = container.helpers
+        }
+      }
+    }
+
     // If new support objects are added, update the proxy support
     if (newContainer.support) {
       const newProxySupport = createSupportObjects(newContainer.support)
@@ -248,10 +259,10 @@ class Container {
     // 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))
-    
+
     if (!options.local) {
       WorkerStorage.share(data)
     }
@@ -347,6 +358,16 @@ async function createHelpers(config) {
     }
   }
 
+  // Set helpers property on each helper to allow access to other helpers
+  for (const name in helpers) {
+    if (helpers[name] && typeof helpers[name] === 'object') {
+      helpers[name].helpers = helpers
+    }
+  }
+
+  // Wait for async helpers and call _init
+  await asyncHelperPromise
+
   for (const name in helpers) {
     if (helpers[name]._init) await helpers[name]._init()
   }
@@ -674,12 +695,50 @@ async function loadSupportObject(modulePath, supportObjectName) {
   try {
     // Use dynamic import for both ESM and CJS modules
     let importPath = modulePath
-    // Append .js if no extension provided (ESM resolution requires it)
+    let tempJsFile = null
+
     if (typeof importPath === 'string') {
       const ext = path.extname(importPath)
-      if (!ext) importPath = `${importPath}.js`
+
+      // Handle TypeScript files
+      if (ext === '.ts') {
+        try {
+          // Use the TypeScript transpilation utility
+          const typescript = await import('typescript')
+          const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
+
+          debug(`Transpiled TypeScript file: ${importPath} -> ${tempFile}`)
+
+          // Attach cleanup handler
+          importPath = tempFile
+          // Store temp files list in a way that cleanup can access them
+          tempJsFile = allTempFiles
+        } catch (tsError) {
+          throw new Error(`Failed to load TypeScript file ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
+        }
+      } else if (!ext) {
+        // Append .js if no extension provided (ESM resolution requires it)
+        importPath = `${importPath}.js`
+      }
+    }
+
+    let obj
+    try {
+      obj = await import(importPath)
+    } catch (importError) {
+      // Clean up temp files if created before rethrowing
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
+      throw importError
+    } finally {
+      // Clean up temp files if created
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
     }
-    const obj = await import(importPath)
 
     // Handle ESM module wrapper
     let actualObj = obj

package/lib/mocha/gherkin.js

@@ -1,4 +1,4 @@
-import Gherkin from '@cucumber/gherkin'
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin'
 import { IdGenerator } from '@cucumber/messages'
 import { Context, Suite } from 'mocha'
 import debug from 'debug'
@@ -15,9 +15,9 @@ import { createTest } from './test.js'
 import { matchStep } from './bdd.js'
 
 const uuidFn = IdGenerator.uuid()
-const builder = new Gherkin.AstBuilder(uuidFn)
-const matcher = new Gherkin.GherkinClassicTokenMatcher()
-const parser = new Gherkin.Parser(builder, matcher)
+const builder = new AstBuilder(uuidFn)
+const matcher = new GherkinClassicTokenMatcher()
+const parser = new Parser(builder, matcher)
 parser.stopAtFirstError = false
 
 const gherkinParser = (text, file) => {

package/lib/plugin/htmlReporter.js

@@ -143,7 +143,7 @@ export default function (config) {
 
   event.dispatcher.on(event.step.finished, step => {
     if (step.htmlReporterStartTime) {
-      step.duration = Date.now() - step.htmlReporterStartTime
+      step.htmlReporterDuration = Date.now() - step.htmlReporterStartTime
     }
 
     // Serialize args immediately to preserve them through worker serialization
@@ -170,7 +170,7 @@ export default function (config) {
       actor: step.actor,
       args: serializedArgs,
       status: step.failed ? 'failed' : 'success',
-      duration: step.duration || 0,
+      duration: step.htmlReporterDuration || step.duration || 0,
     })
   })
 
@@ -210,13 +210,13 @@ export default function (config) {
 
   event.dispatcher.on(event.bddStep.finished, step => {
     if (step.htmlReporterStartTime) {
-      step.duration = Date.now() - step.htmlReporterStartTime
+      step.htmlReporterDuration = Date.now() - step.htmlReporterStartTime
     }
     currentBddSteps.push({
       keyword: step.actor || 'Given',
       text: step.name,
       status: step.failed ? 'failed' : 'success',
-      duration: step.duration || 0,
+      duration: step.htmlReporterDuration || step.duration || 0,
       comment: step.comment,
     })
   })

package/lib/utils/loaderCheck.js

@@ -0,0 +1,124 @@
+/**
+ * Utilities for checking TypeScript loader availability
+ */
+
+/**
+ * Check if a TypeScript loader is available for test files
+ * Note: This checks if loaders are in the require array, not if packages are installed
+ * Package installation is checked when actually requiring modules
+ * @param {string[]} requiredModules - Array of required modules from config
+ * @returns {boolean}
+ */
+export function checkTypeScriptLoader(requiredModules = []) {
+  // Check if a loader is configured in the require array
+  return (
+    requiredModules.includes('tsx/esm') ||
+    requiredModules.includes('tsx/cjs') ||
+    requiredModules.includes('tsx') ||
+    requiredModules.includes('ts-node/esm') ||
+    requiredModules.includes('ts-node/register') ||
+    requiredModules.includes('ts-node')
+  )
+}
+
+/**
+ * Generate helpful error message if .ts tests found but no loader configured
+ * @param {string[]} testFiles - Array of test file paths
+ * @returns {string|null} Error message or null if no TypeScript files
+ */
+export function getTypeScriptLoaderError(testFiles) {
+  const tsFiles = testFiles.filter(f => f.endsWith('.ts'))
+
+  if (tsFiles.length === 0) return null
+
+  return `
+╔═════════════════════════════════════════════════════════════════════════════╗
+║                                                                             ║
+║  ⚠️  TypeScript Test Files Detected but No Loader Configured                ║
+║                                                                             ║
+╚═════════════════════════════════════════════════════════════════════════════╝
+
+Found ${tsFiles.length} TypeScript test file(s) but no TypeScript loader is configured.
+
+CodeceptJS 4.x uses ES Modules (ESM) and requires a loader to run TypeScript tests.
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Option 1: tsx (Recommended - Fast, Zero Config)                            │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+  Installation:
+    npm install --save-dev tsx
+
+  Configuration:
+    Add to your codecept.conf.ts or codecept.conf.js:
+
+    export const config = {
+      tests: './**/*_test.ts',
+      require: ['tsx/cjs'],  // ← Add this line
+      helpers: { /* ... */ }
+    }
+
+  Why tsx?
+    ⚡ Fast: Built on esbuild
+    🎯 Zero config: No tsconfig.json required
+    ✅ Works with Mocha: Uses CommonJS hooks
+    ✅ Complete: Handles all TypeScript features
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Option 2: ts-node/esm (Alternative - Established, Requires Config)         │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+  Installation:
+    npm install --save-dev ts-node
+
+  Configuration:
+    1. Add to your codecept.conf.ts:
+       require: ['ts-node/esm']
+
+    2. Create tsconfig.json:
+       {
+         "compilerOptions": {
+           "module": "ESNext",
+           "target": "ES2022",
+           "moduleResolution": "node",
+           "esModuleInterop": true
+         },
+         "ts-node": {
+           "esm": true,
+           "experimentalSpecifierResolution": "node"
+         }
+       }
+
+📚 Documentation: https://codecept.io/typescript
+
+Note: TypeScript config files (codecept.conf.ts) and helpers are automatically
+      transpiled. Only test files require a loader to be configured.
+`
+}
+
+/**
+ * Check if user is trying to run TypeScript tests without proper loader
+ * @param {string[]} testFiles - Array of test file paths
+ * @param {string[]} requiredModules - Array of required modules from config
+ * @returns {{hasError: boolean, message: string|null}}
+ */
+export function validateTypeScriptSetup(testFiles, requiredModules = []) {
+  const tsFiles = testFiles.filter(f => f.endsWith('.ts'))
+
+  if (tsFiles.length === 0) {
+    // No TypeScript test files, all good
+    return { hasError: false, message: null }
+  }
+
+  // Check if a loader is configured in the require array
+  const hasLoader = checkTypeScriptLoader(requiredModules)
+
+  if (hasLoader) {
+    // Loader configured, all good (package will be checked when requireModules runs)
+    return { hasError: false, message: null }
+  }
+
+  // No loader configured and TypeScript tests exist
+  const message = getTypeScriptLoaderError(testFiles)
+  return { hasError: true, message }
+}

package/lib/utils/typescript.js

@@ -0,0 +1,237 @@
+import fs from 'fs'
+import path from 'path'
+
+/**
+ * Transpile TypeScript files to ES modules with CommonJS shim support
+ * Handles recursive transpilation of imported TypeScript files
+ * 
+ * @param {string} mainFilePath - Path to the main TypeScript file to transpile
+ * @param {object} typescript - TypeScript compiler instance
+ * @returns {Promise<{tempFile: string, allTempFiles: string[]}>} - Main temp file and all temp files created
+ */
+export async function transpileTypeScript(mainFilePath, typescript) {
+  const { transpile } = typescript
+
+  /**
+   * Transpile a single TypeScript file to JavaScript
+   * Injects CommonJS shims (require, module, exports, __dirname, __filename) as needed
+   */
+  const transpileTS = (filePath) => {
+    const tsContent = fs.readFileSync(filePath, 'utf8')
+    
+    // Transpile TypeScript to JavaScript with ES module output
+    let jsContent = transpile(tsContent, {
+      module: 99, // ModuleKind.ESNext
+      target: 99, // ScriptTarget.ESNext
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      lib: ['lib.esnext.d.ts'], // Enable latest features including top-level await
+      suppressOutputPathCheck: true,
+      skipLibCheck: true,
+    })
+    
+    // Check if the code uses CommonJS globals
+    const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
+    const usesRequire = /\brequire\s*\(/.test(jsContent)
+    const usesModuleExports = /\b(module\.exports|exports\.)/.test(jsContent)
+    
+    if (usesCommonJSGlobals || usesRequire || usesModuleExports) {
+      // Inject ESM equivalents at the top of the file
+      let esmGlobals = ''
+      
+      if (usesRequire || usesModuleExports) {
+        // IMPORTANT: Use the original .ts file path as the base for require()
+        // This ensures dynamic require() calls work with relative paths from the original file location
+        const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
+        esmGlobals += `import { createRequire } from 'module';
+import { extname as __extname } from 'path';
+const __baseRequire = createRequire('${originalFileUrl}');
+
+// Wrap require to auto-resolve extensions (mimics CommonJS behavior)
+const require = (id) => {
+  try {
+    return __baseRequire(id);
+  } catch (err) {
+    // If module not found and it's a relative/absolute path without extension, try common extensions
+    if (err.code === 'MODULE_NOT_FOUND' && (id.startsWith('./') || id.startsWith('../') || id.startsWith('/'))) {
+      const ext = __extname(id);
+      // Only treat known file extensions as real extensions (so names like .TEST don't block probing)
+      const __knownExts = ['.js', '.cjs', '.mjs', '.json', '.node'];
+      const hasKnownExt = ext && __knownExts.includes(ext.toLowerCase());
+      if (!hasKnownExt) {
+        // Try common extensions in order: .js, .cjs, .json, .node
+        // Note: .ts files cannot be required - they need transpilation first
+        const extensions = ['.js', '.cjs', '.json', '.node'];
+        for (const testExt of extensions) {
+          try {
+            return __baseRequire(id + testExt);
+          } catch (e) {
+            // Continue to next extension
+          }
+        }
+      }
+    }
+    // Re-throw original error if all attempts failed
+    throw err;
+  }
+};
+
+const module = { exports: {} };
+const exports = module.exports;
+
+`
+      }
+      
+      if (usesCommonJSGlobals) {
+        // For __dirname and __filename, also use the original file path
+        const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
+        esmGlobals += `import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const __filename = '${filePath.replace(/\\/g, '/')}';
+const __dirname = __dirname_fn(__filename);
+
+`
+      }
+      
+      jsContent = esmGlobals + jsContent
+      
+      // If module.exports is used, we need to export it as default
+      if (usesModuleExports) {
+        jsContent += `\nexport default module.exports;\n`
+      }
+    }
+    
+    return jsContent
+  }
+  
+  // Create a map to track transpiled files
+  const transpiledFiles = new Map()
+  const baseDir = path.dirname(mainFilePath)
+  
+  // Recursive function to transpile a file and all its TypeScript dependencies
+  const transpileFileAndDeps = (filePath) => {
+    // Already transpiled, skip
+    if (transpiledFiles.has(filePath)) {
+      return
+    }
+    
+    // Transpile this file
+    let jsContent = transpileTS(filePath)
+    
+    // Find all relative TypeScript imports in this file
+    const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+    let match
+    const imports = []
+    
+    while ((match = importRegex.exec(jsContent)) !== null) {
+      imports.push(match[1])
+    }
+    
+    // Get the base directory for this file
+    const fileBaseDir = path.dirname(filePath)
+    
+    // Recursively transpile each imported TypeScript file
+    for (const relativeImport of imports) {
+      let importedPath = path.resolve(fileBaseDir, relativeImport)
+      
+      // Handle .js extensions that might actually be .ts files
+      if (importedPath.endsWith('.js')) {
+        const tsVersion = importedPath.replace(/\.js$/, '.ts')
+        if (fs.existsSync(tsVersion)) {
+          importedPath = tsVersion
+        }
+      }
+      
+      // Try adding .ts extension if file doesn't exist and no extension provided
+      if (!path.extname(importedPath)) {
+        const tsPath = importedPath + '.ts'
+        if (fs.existsSync(tsPath)) {
+          importedPath = tsPath
+        } else {
+          // Try .js extension as well
+          const jsPath = importedPath + '.js'
+          if (fs.existsSync(jsPath)) {
+            // Skip .js files, they don't need transpilation
+            continue
+          }
+        }
+      }
+      
+      // If it's a TypeScript file, recursively transpile it and its dependencies
+      if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+        transpileFileAndDeps(importedPath)
+      }
+    }
+    
+    // After all dependencies are transpiled, rewrite imports in this file
+    jsContent = jsContent.replace(
+      /from\s+['"](\..+?)(?:\.ts)?['"]/g,
+      (match, importPath) => {
+        let resolvedPath = path.resolve(fileBaseDir, importPath)
+        
+        // Handle .js extension that might be .ts
+        if (resolvedPath.endsWith('.js')) {
+          const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+          if (transpiledFiles.has(tsVersion)) {
+            const tempFile = transpiledFiles.get(tsVersion)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            // Ensure the path starts with ./
+            if (!relPath.startsWith('.')) {
+              return `from './${relPath}'`
+            }
+            return `from '${relPath}'`
+          }
+        }
+        
+        // Try with .ts extension
+        const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+        
+        // If we transpiled this file, use the temp file
+        if (transpiledFiles.has(tsPath)) {
+          const tempFile = transpiledFiles.get(tsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          // Ensure the path starts with ./
+          if (!relPath.startsWith('.')) {
+            return `from './${relPath}'`
+          }
+          return `from '${relPath}'`
+        }
+        
+        // Otherwise, keep the import as-is
+        return match
+      }
+    )
+    
+    // Write the transpiled file with updated imports
+    const tempFile = filePath.replace(/\.ts$/, '.temp.mjs')
+    fs.writeFileSync(tempFile, jsContent)
+    transpiledFiles.set(filePath, tempFile)
+  }
+  
+  // Start recursive transpilation from the main file
+  transpileFileAndDeps(mainFilePath)
+  
+  // Get the main transpiled file
+  const tempJsFile = transpiledFiles.get(mainFilePath)
+  
+  // Store all temp files for cleanup
+  const allTempFiles = Array.from(transpiledFiles.values())
+  
+  return { tempFile: tempJsFile, allTempFiles }
+}
+
+/**
+ * Clean up temporary transpiled files
+ * @param {string[]} tempFiles - Array of temp file paths to delete
+ */
+export function cleanupTempFiles(tempFiles) {
+  for (const file of tempFiles) {
+    if (fs.existsSync(file)) {
+      try {
+        fs.unlinkSync(file)
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-beta.9.esm-aria",
+  "version": "4.0.1-beta.1",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -183,6 +183,7 @@
     "ts-node": "10.9.2",
     "tsd": "^0.33.0",
     "tsd-jsdoc": "2.5.0",
+    "tsx": "^4.19.2",
     "typedoc": "0.28.13",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.8.3",
@@ -191,6 +192,14 @@
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },
+  "peerDependencies": {
+    "tsx": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tsx": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=5.6.0"

package/typings/promiseBasedTypes.d.ts

@@ -2742,6 +2742,7 @@ declare namespace CodeceptJS {
      *   `grabStorageState({ indexedDB: true })`) IndexedDB data; treat as sensitive and do not commit.
      */
     // @ts-ignore
+    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -6142,6 +6143,7 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -7987,6 +7989,7 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -9143,6 +9146,7 @@ declare namespace CodeceptJS {
      * @property [logLevel = silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
      */
     // @ts-ignore
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;

package/typings/types.d.ts

@@ -2832,6 +2832,7 @@ declare namespace CodeceptJS {
      *   `grabStorageState({ indexedDB: true })`) IndexedDB data; treat as sensitive and do not commit.
      */
     // @ts-ignore
+    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -6383,6 +6384,7 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -8364,6 +8366,7 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -9580,6 +9583,7 @@ declare namespace CodeceptJS {
      * @property [logLevel = silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
      */
     // @ts-ignore
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;