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

package/lib/actor.js

@@ -75,7 +75,8 @@ export default function (obj = {}, container) {
   if (!container) {
     container = Container
   }
-  
+
+  // Get existing actor or create a new one
   const actor = container.actor() || new Actor()
 
   // load all helpers once container initialized
@@ -111,14 +112,17 @@ export default function (obj = {}, container) {
       }
     })
 
-    container.append({
-      support: {
-        I: actor,
-      },
-    })
+    // Update container.support.I to ensure it has the latest actor reference
+    if (!container.actor() || container.actor() !== actor) {
+      container.append({
+        support: {
+          I: actor,
+        },
+      })
+    }
   })
-  // store.actor = actor;
-  // add custom steps from actor
+
+  // add custom steps from actor immediately
   Object.keys(obj).forEach(key => {
     const ms = new MetaStep('I', key)
     ms.setContext(actor)

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'
@@ -20,6 +22,7 @@ let container = {
   helpers: {},
   support: {},
   proxySupport: {},
+  proxySupportConfig: {}, // Track config used to create proxySupport
   plugins: {},
   actor: null,
   /**
@@ -30,7 +33,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
 }
 
 /**
@@ -65,14 +68,15 @@ class Container {
     container.support = {}
     container.helpers = await createHelpers(config.helpers || {})
     container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
-    container.proxySupport = createSupportObjects(config.include || {})
+    container.proxySupportConfig = config.include || {}
+    container.proxySupport = createSupportObjects(container.proxySupportConfig)
     container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
     // Preload includes (so proxies can expose real objects synchronously)
     const includes = config.include || {}
 
-    // Ensure I is available for DI modules at import time
+    // Check if custom I is provided
     if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
       try {
         const mod = includes.I
@@ -87,7 +91,7 @@ class Container {
         throw new Error(`Could not include object I: ${e.message}`)
       }
     } else {
-      // Create default actor if not provided via includes
+      // Create default actor - this sets up the callback in asyncHelperPromise
       createActor()
     }
 
@@ -108,6 +112,9 @@ class Container {
       }
     }
 
+    // Wait for all async helpers to finish loading and populate the actor
+    await asyncHelperPromise
+
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
     if (config.gherkin) await loadGherkinStepsAsync(config.gherkin.steps || [])
     if (opts && typeof opts.timeouts === 'boolean') store.timeouts = opts.timeouts
@@ -202,8 +209,10 @@ class Container {
 
     // If new support objects are added, update the proxy support
     if (newContainer.support) {
-      const newProxySupport = createSupportObjects(newContainer.support)
-      container.proxySupport = { ...container.proxySupport, ...newProxySupport }
+      // Merge the new support config with existing config
+      container.proxySupportConfig = { ...container.proxySupportConfig, ...newContainer.support }
+      // Recreate the proxy with merged config
+      container.proxySupport = createSupportObjects(container.proxySupportConfig)
     }
 
     debug('appended', JSON.stringify(newContainer).slice(0, 300))
@@ -219,6 +228,7 @@ class Container {
   static async clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
     container.helpers = newHelpers
     container.translation = await loadTranslation()
+    container.proxySupportConfig = newSupport
     container.proxySupport = createSupportObjects(newSupport)
     container.plugins = newPlugins
     container.sharedKeys = new Set() // Clear shared keys
@@ -248,10 +258,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)
     }
@@ -290,7 +300,7 @@ async function createHelpers(config) {
       if (!HelperClass) {
         const helperResult = requireHelperFromModule(helperName, config)
         if (helperResult instanceof Promise) {
-          // Handle async ESM loading
+          // Handle async ESM loading - create placeholder
           helpers[helperName] = {}
           asyncHelperPromise = asyncHelperPromise
             .then(() => helperResult)
@@ -309,8 +319,7 @@ async function createHelpers(config) {
 
               checkHelperRequirements(ResolvedHelperClass)
               helpers[helperName] = new ResolvedHelperClass(config[helperName])
-              if (helpers[helperName]._init) await helpers[helperName]._init()
-              debug(`helper ${helperName} async initialized`)
+              debug(`helper ${helperName} async loaded`)
             })
           continue
         } else {
@@ -330,9 +339,8 @@ async function createHelpers(config) {
               throw new Error(`Helper class from module '${helperName}' is not a class. Use CJS async module syntax.`)
             }
 
-            debug(`helper ${helperName} async initialized`)
-
             helpers[helperName] = new ResolvedHelperClass(config[helperName])
+            debug(`helper ${helperName} async CJS loaded`)
           })
 
         continue
@@ -347,9 +355,18 @@ async function createHelpers(config) {
     }
   }
 
-  for (const name in helpers) {
-    if (helpers[name]._init) await helpers[name]._init()
-  }
+  // Don't await here - let Container.create() handle the await
+  // This allows actor callbacks to be registered before resolution
+  asyncHelperPromise = asyncHelperPromise.then(async () => {
+    // Call _init on all helpers after they're all loaded
+    for (const name in helpers) {
+      if (helpers[name]._init) {
+        await helpers[name]._init()
+        debug(`helper ${name} _init() called`)
+      }
+    }
+  })
+
   return helpers
 }
 
@@ -381,20 +398,52 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       throw err
     }
   } else {
+    // Handle TypeScript files
+    let importPath = moduleName
+    let tempJsFile = null
+    const ext = path.extname(moduleName)
+
+    if (ext === '.ts') {
+      try {
+        // Use the TypeScript transpilation utility
+        const typescript = await import('typescript')
+        const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
+
+        debug(`Transpiled TypeScript helper: ${importPath} -> ${tempFile}`)
+
+        importPath = tempFile
+        tempJsFile = allTempFiles
+      } catch (tsError) {
+        throw new Error(`Failed to load TypeScript helper ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
+      }
+    }
+
     // 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 {
       // Try dynamic import for both CommonJS and ESM modules
-      const mod = await import(moduleName)
+      const mod = await import(importPath)
       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
+
+      // Clean up temp files if created
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
     } catch (err) {
+      // Clean up temp files before rethrowing
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
+
       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 absolutePath = pathModule.default.resolve(importPath)
           const mod = await import(absolutePath)
           HelperClass = mod.default || mod
           debug(`helper ${helperName} loaded via ESM import`)
@@ -523,10 +572,17 @@ function createSupportObjects(config) {
         return [...new Set([...keys, ...container.sharedKeys])]
       },
       getOwnPropertyDescriptor(target, prop) {
+        // For destructuring to work, we need to return the actual value from the getter
+        let value
+        if (container.sharedKeys.has(prop) && prop in container.support) {
+          value = container.support[prop]
+        } else {
+          value = lazyLoad(prop)
+        }
         return {
           enumerable: true,
           configurable: true,
-          value: target[prop],
+          value: value,
         }
       },
       get(target, key) {
@@ -674,12 +730,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/helper/GraphQL.js

@@ -45,6 +45,8 @@ class GraphQL extends Helper {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
+      onRequest: null,
+      onResponse: null,
     }
     this.options = Object.assign(this.options, config)
     this.headers = { ...this.options.defaultHeaders }
@@ -87,8 +89,8 @@ class GraphQL extends Helper {
 
     request.headers = { ...this.headers, ...request.headers }
 
-    if (this.config.onRequest) {
-      await this.config.onRequest(request)
+    if (this.options.onRequest) {
+      await this.options.onRequest(request)
     }
 
     this.debugSection('Request', JSON.stringify(request))
@@ -102,8 +104,8 @@ class GraphQL extends Helper {
       response = err.response
     }
 
-    if (this.config.onResponse) {
-      await this.config.onResponse(response)
+    if (this.options.onResponse) {
+      await this.options.onResponse(response)
     }
 
     this.debugSection('Response', JSON.stringify(response.data))

package/lib/helper/JSONResponse.js

@@ -72,8 +72,8 @@ class JSONResponse extends Helper {
     if (!this.helpers[this.options.requestHelper]) {
       throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
     }
-    const origOnResponse = this.helpers[this.options.requestHelper].config.onResponse
-    this.helpers[this.options.requestHelper].config.onResponse = response => {
+    const origOnResponse = this.helpers[this.options.requestHelper].options.onResponse
+    this.helpers[this.options.requestHelper].options.onResponse = response => {
       this.response = response
       if (typeof origOnResponse === 'function') origOnResponse(response)
     }
@@ -83,7 +83,6 @@ class JSONResponse extends Helper {
     this.response = null
   }
 
-  
   /**
    * Checks that response code is equal to the provided one
    *
@@ -372,4 +371,4 @@ class JSONResponse extends Helper {
   }
 }
 
-export { JSONResponse as default }
+export { JSONResponse, JSONResponse as default }

package/lib/helper/Playwright.js

@@ -355,7 +355,7 @@ class Playwright extends Helper {
     this.recordingWebSocketMessages = false
     this.recordedWebSocketMessagesAtLeastOnce = false
     this.cdpSession = null
-    
+
     // Filter out invalid customLocatorStrategies (empty arrays, objects without functions)
     // This can happen in worker threads where config is serialized/deserialized
     let validCustomLocators = null
@@ -367,7 +367,7 @@ class Playwright extends Helper {
         validCustomLocators = config.customLocatorStrategies
       }
     }
-    
+
     this.customLocatorStrategies = validCustomLocators
     this._customLocatorsRegistered = false
 
@@ -416,6 +416,7 @@ class Playwright extends Helper {
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
       storageState: undefined,
+      onResponse: null,
     }
 
     process.env.testIdAttribute = 'data-testid'
@@ -794,10 +795,7 @@ class Playwright extends Helper {
             await Promise.allSettled(pages.map(p => p.close().catch(() => {})))
           }
           // Use timeout to prevent hanging (10s should be enough for browser cleanup)
-          await Promise.race([
-            this._stopBrowser(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout')), 10000)),
-          ])
+          await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout')), 10000))])
         } catch (e) {
           console.warn('Warning during browser restart in _after:', e.message)
           // Force cleanup even on timeout
@@ -840,10 +838,7 @@ class Playwright extends Helper {
     if (this.isRunning) {
       try {
         // Add timeout protection to prevent hanging
-        await Promise.race([
-          this._stopBrowser(),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in afterSuite')), 10000)),
-        ])
+        await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in afterSuite')), 10000))])
       } catch (e) {
         console.warn('Warning during suite cleanup:', e.message)
         // Track suite cleanup failures
@@ -954,10 +949,7 @@ class Playwright extends Helper {
     if (this.isRunning) {
       try {
         // Add timeout protection to prevent hanging
-        await Promise.race([
-          this._stopBrowser(),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in cleanup')), 10000)),
-        ])
+        await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in cleanup')), 10000))])
       } catch (e) {
         console.warn('Warning during final cleanup:', e.message)
         // Force cleanup on timeout
@@ -970,10 +962,7 @@ class Playwright extends Helper {
       if (this.browser) {
         try {
           // Add timeout protection to prevent hanging
-          await Promise.race([
-            this._stopBrowser(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in forced cleanup')), 10000)),
-          ])
+          await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in forced cleanup')), 10000))])
         } catch (e) {
           console.warn('Warning during forced cleanup:', e.message)
           // Force cleanup on timeout
@@ -1390,7 +1379,7 @@ class Playwright extends Helper {
     this.context = null
     this.frame = null
     popupStore.clear()
-    
+
     // Remove all event listeners to prevent hanging
     if (this.browser) {
       try {
@@ -1399,7 +1388,7 @@ class Playwright extends Helper {
         // Ignore errors if browser is already closed
       }
     }
-    
+
     if (this.options.recordHar && this.browserContext) {
       try {
         await this.browserContext.close()
@@ -1408,16 +1397,11 @@ class Playwright extends Helper {
       }
     }
     this.browserContext = null
-    
+
     if (this.browser) {
       try {
         // Add timeout to prevent browser.close() from hanging indefinitely
-        await Promise.race([
-          this.browser.close(),
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Browser close timeout')), 5000)
-          )
-        ])
+        await Promise.race([this.browser.close(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser close timeout')), 5000))])
       } catch (e) {
         // Ignore errors if browser is already closed or timeout
         if (!e.message?.includes('Browser close timeout')) {
@@ -1539,7 +1523,7 @@ class Playwright extends Helper {
           acceptDownloads: true,
           ...this.options.emulate,
         }
-        
+
         try {
           this.browserContext = await this.browser.newContext(contextOptions)
         } catch (err) {
@@ -3183,14 +3167,14 @@ class Playwright extends Helper {
     this.debugSection('Response', await response.text())
 
     // hook to allow JSON response handle this
-    if (this.config.onResponse) {
+    if (this.options.onResponse) {
       const axiosResponse = {
         data: await response.json(),
         status: response.status(),
         statusText: response.statusText(),
         headers: response.headers(),
       }
-      this.config.onResponse(axiosResponse)
+      this.options.onResponse(axiosResponse)
     }
 
     return response
@@ -4337,11 +4321,11 @@ function isRoleLocatorObject(locator) {
  */
 async function handleRoleLocator(context, locator) {
   if (!isRoleLocatorObject(locator)) return null
-  
+
   const options = {}
   if (locator.text) options.name = locator.text
   if (locator.exact !== undefined) options.exact = locator.exact
-  
+
   return context.getByRole(locator.role, Object.keys(options).length > 0 ? options : undefined).all()
 }
 
@@ -4350,7 +4334,7 @@ async function findElements(matcher, locator) {
   const isReactLocator = locator.type === 'react' || (locator.locator && locator.locator.react) || locator.react
   const isVueLocator = locator.type === 'vue' || (locator.locator && locator.locator.vue) || locator.vue
   const isPwLocator = locator.type === 'pw' || (locator.locator && locator.locator.pw) || locator.pw
-  
+
   if (isReactLocator) return findReact(matcher, locator)
   if (isVueLocator) return findVue(matcher, locator)
   if (isPwLocator) return findByPlaywrightLocator.call(this, matcher, locator)
@@ -4391,7 +4375,7 @@ async function findCustomElements(matcher, locator) {
   // Always prioritize this.customLocatorStrategies which is set in constructor from config
   // and persists in every worker thread instance
   let strategyFunction = null
-  
+
   if (this.customLocatorStrategies && this.customLocatorStrategies[locator.type]) {
     strategyFunction = this.customLocatorStrategies[locator.type]
   } else if (globalCustomLocatorStrategies.has(locator.type)) {
@@ -4967,7 +4951,7 @@ async function refreshContextSession() {
       this.debugSection('Session', 'Skipping storage cleanup - no active page/context')
       return
     }
-    
+
     const currentUrl = await this.grabCurrentUrl()
 
     if (currentUrl.startsWith('http')) {