codeceptjs 4.0.0-beta.12 → 4.0.0-beta.14

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

@@ -5,6 +5,7 @@ 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'
@@ -683,124 +684,14 @@ async function loadSupportObject(modulePath, supportObjectName) {
       // Handle TypeScript files
       if (ext === '.ts') {
         try {
-          const { transpile } = await import('typescript')
+          // Use the TypeScript transpilation utility
+          const typescript = await import('typescript')
+          const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
           
-          // Recursively transpile the file and its dependencies
-          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,
-            })
-            
-            // Check if the code uses __dirname or __filename (CommonJS globals)
-            const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
-            
-            if (usesCommonJSGlobals) {
-              // Inject ESM equivalents at the top of the file
-              const esmGlobals = `import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __dirname_fn } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __dirname_fn(__filename);
-
-`
-              jsContent = esmGlobals + jsContent
-            }
-            
-            return jsContent
-          }
-          
-          // Create a map to track transpiled files
-          const transpiledFiles = new Map()
-          const baseDir = path.dirname(importPath)
-          
-          // Transpile main file
-          let jsContent = transpileTS(importPath)
-          
-          // Find and transpile all relative TypeScript imports
-          // Match: import ... from './file' or '../file' or './file.ts'
-          const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
-          let match
-          const imports = []
-          
-          while ((match = importRegex.exec(jsContent)) !== null) {
-            imports.push(match[1])
-          }
-          
-          // Transpile each imported TypeScript file
-          for (const relativeImport of imports) {
-            let importedPath = path.resolve(baseDir, 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)) {
-              if (fs.existsSync(importedPath + '.ts')) {
-                importedPath = importedPath + '.ts'
-              }
-            }
-            
-            // If it's a TypeScript file, transpile it
-            if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
-              const transpiledImportContent = transpileTS(importedPath)
-              const tempImportFile = importedPath.replace(/\.ts$/, '.temp.mjs')
-              fs.writeFileSync(tempImportFile, transpiledImportContent)
-              transpiledFiles.set(importedPath, tempImportFile)
-              debug(`Transpiled dependency: ${importedPath} -> ${tempImportFile}`)
-            }
-          }
-          
-          // Replace imports in the main file to point to temp .mjs files
-          jsContent = jsContent.replace(
-            /from\s+['"](\..+?)(?:\.ts)?['"]/g,
-            (match, importPath) => {
-              let resolvedPath = path.resolve(baseDir, 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(baseDir, tempFile).replace(/\\/g, '/')
-                  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)
-                // Get relative path from main temp file to this temp file
-                const relPath = path.relative(baseDir, tempFile).replace(/\\/g, '/')
-                return `from './${relPath}'`
-              }
-              
-              // Otherwise, keep the import as-is
-              return match
-            }
-          )
-
-          // Create a temporary JS file with .mjs extension for the main file
-          tempJsFile = importPath.replace(/\.ts$/, '.temp.mjs')
-          fs.writeFileSync(tempJsFile, jsContent)
-          
-          // Store all temp files for cleanup
-          const allTempFiles = [tempJsFile, ...Array.from(transpiledFiles.values())]
+          debug(`Transpiled TypeScript file: ${importPath} -> ${tempFile}`)
           
           // Attach cleanup handler
-          importPath = tempJsFile
+          importPath = tempFile
           // Store temp files list in a way that cleanup can access them
           tempJsFile = allTempFiles
           
@@ -820,30 +711,14 @@ const __dirname = __dirname_fn(__filename);
       // Clean up temp files if created before rethrowing
       if (tempJsFile) {
         const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
-        for (const file of filesToClean) {
-          try {
-            if (fs.existsSync(file)) {
-              fs.unlinkSync(file)
-            }
-          } catch (cleanupError) {
-            // Ignore cleanup errors
-          }
-        }
+        cleanupTempFiles(filesToClean)
       }
       throw importError
     } finally {
       // Clean up temp files if created
       if (tempJsFile) {
         const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
-        for (const file of filesToClean) {
-          try {
-            if (fs.existsSync(file)) {
-              fs.unlinkSync(file)
-            }
-          } catch (cleanupError) {
-            // Ignore cleanup errors
-          }
-        }
+        cleanupTempFiles(filesToClean)
       }
     }
 

package/lib/utils/typescript.js

@@ -0,0 +1,169 @@
+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,
+    })
+    
+    // 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) {
+        esmGlobals += `import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const module = { exports: {} };
+const exports = module.exports;
+
+`
+      }
+      
+      if (usesCommonJSGlobals) {
+        esmGlobals += `import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+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)
+  
+  // Transpile main file
+  let jsContent = transpileTS(mainFilePath)
+  
+  // Find and transpile all relative TypeScript imports
+  // Match: import ... from './file' or '../file' or './file.ts'
+  const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+  let match
+  const imports = []
+  
+  while ((match = importRegex.exec(jsContent)) !== null) {
+    imports.push(match[1])
+  }
+  
+  // Transpile each imported TypeScript file
+  for (const relativeImport of imports) {
+    let importedPath = path.resolve(baseDir, 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)) {
+      if (fs.existsSync(importedPath + '.ts')) {
+        importedPath = importedPath + '.ts'
+      }
+    }
+    
+    // If it's a TypeScript file, transpile it
+    if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+      const transpiledImportContent = transpileTS(importedPath)
+      const tempImportFile = importedPath.replace(/\.ts$/, '.temp.mjs')
+      fs.writeFileSync(tempImportFile, transpiledImportContent)
+      transpiledFiles.set(importedPath, tempImportFile)
+    }
+  }
+  
+  // Replace imports in the main file to point to temp .mjs files
+  jsContent = jsContent.replace(
+    /from\s+['"](\..+?)(?:\.ts)?['"]/g,
+    (match, importPath) => {
+      let resolvedPath = path.resolve(baseDir, 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(baseDir, tempFile).replace(/\\/g, '/')
+          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)
+        // Get relative path from main temp file to this temp file
+        const relPath = path.relative(baseDir, tempFile).replace(/\\/g, '/')
+        return `from './${relPath}'`
+      }
+      
+      // Otherwise, keep the import as-is
+      return match
+    }
+  )
+
+  // Create a temporary JS file with .mjs extension for the main file
+  const tempJsFile = mainFilePath.replace(/\.ts$/, '.temp.mjs')
+  fs.writeFileSync(tempJsFile, jsContent)
+  
+  // Store all temp files for cleanup
+  const allTempFiles = [tempJsFile, ...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.12",
+  "version": "4.0.0-beta.14",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [