@wdio/cli 8.0.0-alpha.593 → 8.0.0-alpha.600

package/build/commands/config.d.ts

@@ -5,7 +5,7 @@ export declare const desc = "Initialize WebdriverIO and setup configuration in y
 export declare const cmdArgs: {
     readonly yarn: {
         readonly type: "boolean";
-        readonly desc: "Install packages via yarn package manager.";
+        readonly desc: "Install packages via Yarn package manager.";
         readonly default: boolean;
     };
     readonly yes: {
@@ -14,11 +14,17 @@ export declare const cmdArgs: {
         readonly type: "boolean";
         readonly default: false;
     };
+    readonly npmTag: {
+        readonly alias: "t";
+        readonly desc: "define NPM tag to use for WebdriverIO related packages";
+        readonly type: "string";
+        readonly default: "latest";
+    };
 };
-export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{}, "yarn" | "yes"> & import("yargs").InferredOptionTypes<{
+export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{}, "yarn" | "yes" | "npmTag"> & import("yargs").InferredOptionTypes<{
     readonly yarn: {
         readonly type: "boolean";
-        readonly desc: "Install packages via yarn package manager.";
+        readonly desc: "Install packages via Yarn package manager.";
         readonly default: boolean;
     };
     readonly yes: {
@@ -27,12 +33,16 @@ export declare const builder: (yargs: Argv) => Argv<import("yargs").Omit<{}, "ya
         readonly type: "boolean";
         readonly default: false;
     };
+    readonly npmTag: {
+        readonly alias: "t";
+        readonly desc: "define NPM tag to use for WebdriverIO related packages";
+        readonly type: "string";
+        readonly default: "latest";
+    };
 }>>;
-export declare function handler(argv: ConfigCommandArguments): Promise<{
-    success: boolean;
-    parsedAnswers?: undefined;
-    installedPackages?: undefined;
-} | {
+export declare const parseAnswers: (yes: boolean) => Promise<ParsedAnswers>;
+export declare function runConfigCommand(parsedAnswers: ParsedAnswers, useYarn: boolean, npmTag: string): Promise<void>;
+export declare function handler(argv: ConfigCommandArguments, runConfigCmd?: typeof runConfigCommand): Promise<{
     success: boolean;
     parsedAnswers: ParsedAnswers;
     installedPackages: string[];
@@ -44,21 +54,5 @@ export declare function handler(argv: ConfigCommandArguments): Promise<{
  * @param {boolean}  useYarn        parameter set to true if yarn is used
  * @param {Function} runConfigCmd   runConfig method to be replaceable for unit testing
  */
-export declare function missingConfigurationPrompt(command: string, message: string, useYarn?: boolean, runConfigCmd?: (useYarn: boolean, yes: boolean, exit?: boolean) => Promise<{
-    success: boolean;
-    parsedAnswers?: undefined;
-    installedPackages?: undefined;
-} | {
-    success: boolean;
-    parsedAnswers: ParsedAnswers;
-    installedPackages: string[];
-}>): Promise<{
-    success: boolean;
-    parsedAnswers?: undefined;
-    installedPackages?: undefined;
-} | {
-    success: boolean;
-    parsedAnswers: ParsedAnswers;
-    installedPackages: string[];
-}>;
+export declare function missingConfigurationPrompt(command: string, message: string, useYarn?: boolean, runConfigCmd?: typeof runConfigCommand): Promise<false | undefined>;
 //# sourceMappingURL=config.d.ts.map

package/build/commands/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAajC,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAErE,eAAO,MAAM,OAAO,WAAW,CAAA;AAC/B,eAAO,MAAM,IAAI,4EAA4E,CAAA;AAE7F,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYV,CAAA;AAEV,eAAO,MAAM,OAAO,UAAW,IAAI;;;;;;;;;;;;GAKlC,CAAA;AA0MD,wBAAgB,OAAO,CAAC,IAAI,EAAE,sBAAsB;;;;;;;;GAEnD;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,UAAQ,EAAE,YAAY;;;;;;;;EAAY;;;;;;;;GA4B3H"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAQjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAIrE,eAAO,MAAM,OAAO,WAAW,CAAA;AAC/B,eAAO,MAAM,IAAI,4EAA4E,CAAA;AAE7F,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAkBV,CAAA;AAEV,eAAO,MAAM,OAAO,UAAW,IAAI;;;;;;;;;;;;;;;;;;GAKlC,CAAA;AAED,eAAO,MAAM,YAAY,QAAwB,OAAO,KAAG,QAAQ,aAAa,CAgF/E,CAAA;AAED,wBAAsB,gBAAgB,CAAE,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAkBrG;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,sBAAsB,EAAE,YAAY,0BAAmB;;;;GAQ1F;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,UAAQ,EAAE,YAAY,0BAAmB,8BA2BlI"}

package/build/commands/config.js

@@ -2,22 +2,28 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import util from 'node:util';
 import inquirer from 'inquirer';
-import yarnInstall from 'yarn-install';
-import { CONFIG_HELPER_INTRO, CLI_EPILOGUE, COMPILER_OPTIONS, CONFIG_HELPER_SUCCESS_MESSAGE, TESTING_LIBRARY_PACKAGES, DEPENDENCIES_INSTALLATION_MESSAGE, SUPPORTED_PACKAGES, pkg } from '../constants.js';
-import { addServiceDeps, convertPackageHashToObject, renderConfigurationFile, hasFile, generateTestFiles, getAnswers, getPathForFileGeneration, hasPackage, specifyVersionIfNeeded } from '../utils.js';
+import { CONFIG_HELPER_INTRO, CLI_EPILOGUE, COMPILER_OPTIONS, SUPPORTED_PACKAGES, CONFIG_HELPER_SUCCESS_MESSAGE } from '../constants.js';
+import { convertPackageHashToObject, getAnswers, getPathForFileGeneration, getProjectProps, getProjectRoot, createPackageJSON, setupTypeScript, setupBabel, npmInstall, createWDIOConfig, createWDIOScript } from '../utils.js';
+const hasYarnLock = await fs.access('yarn.lock').then(() => true, () => false);
 export const command = 'config';
 export const desc = 'Initialize WebdriverIO and setup configuration in your current project.';
 export const cmdArgs = {
     yarn: {
         type: 'boolean',
-        desc: 'Install packages via yarn package manager.',
-        default: hasFile('yarn.lock')
+        desc: 'Install packages via Yarn package manager.',
+        default: hasYarnLock
     },
     yes: {
         alias: 'y',
         desc: 'will fill in all config defaults without prompting',
         type: 'boolean',
         default: false
+    },
+    npmTag: {
+        alias: 't',
+        desc: 'define NPM tag to use for WebdriverIO related packages',
+        type: 'string',
+        default: 'latest'
     }
 };
 export const builder = (yargs) => {
@@ -26,7 +32,7 @@ export const builder = (yargs) => {
         .epilogue(CLI_EPILOGUE)
         .help();
 };
-const runConfig = async function (useYarn, yes, exit = false) {
+export const parseAnswers = async function (yes) {
     console.log(CONFIG_HELPER_INTRO);
     const answers = await getAnswers(yes);
     const frameworkPackage = convertPackageHashToObject(answers.framework);
@@ -35,6 +41,8 @@ const runConfig = async function (useYarn, yes, exit = false) {
     const pluginPackages = answers.plugins.map((plugin) => convertPackageHashToObject(plugin));
     const reporterPackages = answers.reporters.map((reporter) => convertPackageHashToObject(reporter));
     const presetPackage = convertPackageHashToObject(answers.preset || '');
+    const projectProps = await getProjectProps(process.cwd());
+    const projectRootDir = getProjectRoot(answers, projectProps);
     let packagesToInstall = [
         runnerPackage.package,
         frameworkPackage.package,
@@ -46,156 +54,80 @@ const runConfig = async function (useYarn, yes, exit = false) {
     /**
      * find relative paths between tests and pages
      */
-    const parsedPaths = getPathForFileGeneration(answers);
-    const parsedAnswers = {
+    const hasRootTSConfig = await fs.access(path.resolve(projectRootDir, 'tsconfig.json')).then(() => true, () => false);
+    const tsConfigFilePath = !hasRootTSConfig
+        /**
+         * if no tsconfig.json exists in project, create one
+         */
+        ? path.resolve(projectRootDir, 'tsconfig.json')
+        /**
+         * otherwise make it dependant whether user wants to autogenerate files
+         */
+        : answers.specs
+            /**
+             * if we have autogenerated spec files, put the tsconfig one above the spec file dir
+             */
+            ? path.resolve(path.dirname(answers.specs.split('/').filter((s) => !s.includes('*')).join('/')), 'tsconfig.json')
+            /**
+             * if no spec files are auto generated, create a wdio tsconfig and let the user deal with it
+             */
+            : path.resolve(projectRootDir, `tsconfig.${runnerPackage.short === 'local' ? 'e2e' : 'wdio'}.json`);
+    const parsedPaths = getPathForFileGeneration(answers, projectRootDir);
+    const isUsingTypeScript = answers.isUsingCompiler === COMPILER_OPTIONS.ts;
+    const wdioConfigFilename = `wdio.conf.${isUsingTypeScript ? 'ts' : 'js'}`;
+    const wdioConfigPath = path.resolve(projectRootDir, wdioConfigFilename);
+    return {
         // default values required in templates
         ...({
             usePageObjects: false,
             installTestingLibrary: false
         }),
         ...answers,
+        rawAnswers: answers,
         runner: runnerPackage.short,
         preset: presetPackage.short,
         framework: frameworkPackage.short,
         reporters: reporterPackages.map(({ short }) => short),
         plugins: pluginPackages.map(({ short }) => short),
         services: servicePackages.map(({ short }) => short),
+        specs: answers.specs && `.${answers.specs.replace(projectRootDir, '')}`,
         packagesToInstall,
-        isUsingTypeScript: answers.isUsingCompiler === COMPILER_OPTIONS.ts,
+        isUsingTypeScript,
         isUsingBabel: answers.isUsingCompiler === COMPILER_OPTIONS.babel,
+        esmSupport: projectProps?.esmSupported || answers.moduleSystem === 'esm' || answers.isUsingCompiler === COMPILER_OPTIONS.babel,
         isSync: false,
         _async: 'async ',
         _await: 'await ',
+        projectRootDir,
         destSpecRootPath: parsedPaths.destSpecRootPath,
         destPageObjectRootPath: parsedPaths.destPageObjectRootPath,
         relativePath: parsedPaths.relativePath,
-        tsConfigFilePath: path.join(process.cwd(), 'test', 'tsconfig.json')
+        tsConfigFilePath,
+        tsProject: `.${tsConfigFilePath.replace(projectRootDir, '')}`,
+        wdioConfigPath
     };
+};
+export async function runConfigCommand(parsedAnswers, useYarn, npmTag) {
+    console.log('\n');
+    await createPackageJSON(parsedAnswers);
+    await setupTypeScript(parsedAnswers);
+    await setupBabel(parsedAnswers);
+    await npmInstall(parsedAnswers, useYarn, npmTag);
+    await createWDIOConfig(parsedAnswers);
+    await createWDIOScript(parsedAnswers);
     /**
-     * add ts-node if TypeScript is desired but not installed
-     */
-    if (parsedAnswers.isUsingTypeScript) {
-        if (!await hasPackage('ts-node')) {
-            packagesToInstall.push('ts-node', 'typescript');
-        }
-        const types = [
-            'node',
-            '@wdio/globals/types',
-            'expect-webdriverio',
-            frameworkPackage.package,
-            ...(parsedAnswers.runner === 'browser' ? ['@wdio/browser-runner'] : []),
-            ...servicePackages
-                .map(service => service.package)
-                /**
-                 * given that we know that all "offical" services have
-                 * typescript support we only include them
-                 */
-                .filter(service => service.startsWith('@wdio'))
-        ];
-        const config = {
-            compilerOptions: {
-                moduleResolution: 'node',
-                types,
-                target: 'es2022',
-            }
-        };
-        await fs.mkdir(path.join(process.cwd(), 'test'), { recursive: true });
-        await fs.writeFile(parsedAnswers.tsConfigFilePath, JSON.stringify(config, null, 4));
-    }
-    /**
-     * install Testing Library dependency if desired
-     */
-    if (answers.installTestingLibrary) {
-        packagesToInstall.push(TESTING_LIBRARY_PACKAGES[presetPackage.short], '@testing-library/jest-dom');
-    }
-    /**
-     * add @babel/register package if not installed
-     */
-    if (parsedAnswers.isUsingBabel) {
-        if (!await hasPackage('@babel/register')) {
-            packagesToInstall.push('@babel/register');
-        }
-        /**
-         * setup Babel if no config file exists
-         */
-        if (!hasFile('babel.config.js')) {
-            if (!await hasPackage('@babel/core')) {
-                packagesToInstall.push('@babel/core');
-            }
-            if (!await hasPackage('@babel/preset-env')) {
-                packagesToInstall.push('@babel/preset-env');
-            }
-            await fs.writeFile(path.join(process.cwd(), 'babel.config.js'), `module.exports = ${JSON.stringify({
-                presets: [
-                    ['@babel/preset-env', {
-                            targets: {
-                                node: '14'
-                            }
-                        }]
-                ]
-            }, null, 4)}`);
-        }
-    }
-    /**
-     * add packages that are required by services
-     */
-    addServiceDeps(servicePackages, packagesToInstall);
-    /**
-     * update package version if CLI is a pre release
-     */
-    packagesToInstall = specifyVersionIfNeeded(packagesToInstall, pkg.version);
-    /**
-     * run npm install only if required by the user
-     */
-    if (parsedAnswers.npmInstall) {
-        console.log('\nInstalling wdio packages:\n-', packagesToInstall.join('\n- '));
-        const result = yarnInstall({ deps: packagesToInstall, dev: true, respectNpm5: !useYarn });
-        if (result.status !== 0) {
-            const customError = 'An unknown error happened! Please retry ' +
-                `installing dependencies via "${useYarn ? 'yarn add --dev' : 'npm i --save-dev'} ` +
-                `${packagesToInstall.join(' ')}"\n\nError: ${result.stderr || 'unknown'}`;
-            console.log(customError);
-            /**
-             * don't exit if running unit tests
-             */
-            if (exit /* istanbul ignore next */ && !process.env.VITEST_WORKER_ID) {
-                /* istanbul ignore next */
-                process.exit(1);
-            }
-            return { success: false };
-        }
-        console.log('\nPackages installed successfully, creating configuration file...');
-    }
-    else {
-        const installationCommand = `${useYarn ? 'yarn add --dev' : 'npm i --save-dev'} ${packagesToInstall.join(' ')}`;
-        console.log(util.format(DEPENDENCIES_INSTALLATION_MESSAGE, installationCommand));
-    }
-    try {
-        await renderConfigurationFile(parsedAnswers);
-        if (answers.generateTestFiles) {
-            console.log('\nConfig file installed successfully, creating test files...');
-            await generateTestFiles(parsedAnswers);
-        }
-    }
-    catch (err) {
-        throw new Error(`Couldn't write config file: ${err.stack}`);
-    }
-    console.log(util.format(CONFIG_HELPER_SUCCESS_MESSAGE, parsedAnswers.isUsingTypeScript ? 'test/' : '', parsedAnswers.isUsingTypeScript ? 'ts' : 'js'));
-    /**
-     * don't exit if running unit tests
+     * print success message
      */
-    if (exit /* istanbul ignore next */ && !process.env.VITEST_WORKER_ID) {
-        /* istanbul ignore next */
-        process.exit(0);
-    }
+    console.log(util.format(CONFIG_HELPER_SUCCESS_MESSAGE, parsedAnswers.projectRootDir, parsedAnswers.projectRootDir));
+}
+export async function handler(argv, runConfigCmd = runConfigCommand) {
+    const parsedAnswers = await parseAnswers(argv.yes);
+    await runConfigCmd(parsedAnswers, argv.yarn, argv.npmTag);
     return {
         success: true,
         parsedAnswers,
-        installedPackages: packagesToInstall.map((pkg) => pkg.split('--')[0])
+        installedPackages: parsedAnswers.packagesToInstall.map((pkg) => pkg.split('--')[0])
     };
-};
-export function handler(argv) {
-    return runConfig(argv.yarn, argv.yes);
 }
 /**
  * Helper utility used in `run` and `install` command to create config if none exist
@@ -204,28 +136,27 @@ export function handler(argv) {
  * @param {boolean}  useYarn        parameter set to true if yarn is used
  * @param {Function} runConfigCmd   runConfig method to be replaceable for unit testing
  */
-export async function missingConfigurationPrompt(command, message, useYarn = false, runConfigCmd = runConfig) {
+export async function missingConfigurationPrompt(command, message, useYarn = false, runConfigCmd = runConfigCommand) {
     const configMessage = command === 'run'
         ? `Error: Could not execute "run" due to missing configuration, file "${message}" not found! Would you like to create one?`
         : `Error: Could not execute "${command}" due to missing configuration. Would you like to create one?`;
-    const { config } = await inquirer.prompt([
-        {
+    const { config } = await inquirer.prompt([{
             type: 'confirm',
             name: 'config',
             message: configMessage,
             default: false
-        }
-    ]);
+        }]);
     /**
      * don't exit if running unit tests
      */
-    if (!config && !process.env.VITEST_WORKER_ID) {
+    if (!config) {
         /* istanbul ignore next */
         console.log(command === 'run'
             ? `No WebdriverIO configuration found in "${process.cwd()}"`
             : message);
         /* istanbul ignore next */
-        return process.exit(0);
+        return !process.env.VITEST_WORKER_ID && process.exit(0);
     }
-    return await runConfigCmd(useYarn, false, true);
+    const parsedAnswers = await parseAnswers(false);
+    await runConfigCmd(parsedAnswers, useYarn, 'latest');
 }

package/build/commands/install.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/commands/install.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAUjC,OAAO,KAAK,EAAE,uBAAuB,EAAoB,MAAM,UAAU,CAAA;AAUzE,eAAO,MAAM,OAAO,0BAA0B,CAAA;AAC9C,eAAO,MAAM,IAAI,QAIN,CAAA;AAEX,eAAO,MAAM,OAAO;;;;;;;;;;CAUV,CAAA;AAEV,eAAO,MAAM,OAAO,UAAW,IAAI,aAalC,CAAA;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,uBAAuB,iBA0E1D"}
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/commands/install.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAUjC,OAAO,KAAK,EAAE,uBAAuB,EAAoB,MAAM,UAAU,CAAA;AAUzE,eAAO,MAAM,OAAO,0BAA0B,CAAA;AAC9C,eAAO,MAAM,IAAI,QAIN,CAAA;AAEX,eAAO,MAAM,OAAO;;;;;;;;;;CAUV,CAAA;AAEV,eAAO,MAAM,OAAO,UAAW,IAAI,aAalC,CAAA;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,uBAAuB,iBA2E1D"}

package/build/commands/install.js

@@ -68,8 +68,8 @@ export async function handler(argv) {
     const localConfExists = await fs.access(localConfPath).then(() => true, () => false);
     if (!localConfExists) {
         try {
-            const promptMessage = `Cannot install packages without a WebdriverIO configuration.
-You can create one by running 'wdio config'`;
+            const promptMessage = ('Cannot install packages without a WebdriverIO configuration. ' +
+                'You can create one by running \'wdio config\'');
             await missingConfigurationPrompt('install', promptMessage, yarn);
         }
         catch {

package/build/constants.d.ts

@@ -8,7 +8,7 @@ export declare const EXCLUSIVE_SERVICES: {
     };
 };
 export declare const CONFIG_HELPER_INTRO = "\n=========================\nWDIO Configuration Helper\n=========================\n";
-export declare const CONFIG_HELPER_SUCCESS_MESSAGE = "\nConfiguration file was created successfully!\nTo run your tests, execute:\n$ npx wdio run %swdio.conf.%s\n";
+export declare const CONFIG_HELPER_SUCCESS_MESSAGE = "\n\uD83E\uDD16 Successfully setup project at %s \uD83C\uDF89\n\nJoin our Gitter community and instantly find answers to your issues or queries. Or just join and say hi \uD83D\uDC4B!\n  \uD83D\uDD17 https://gitter.im/webdriverio/webdriverio\n\nVisit the project on GitHub to report bugs \uD83D\uDC1B or raise feature requests \uD83D\uDCA1:\n  \uD83D\uDD17 https://github.com/webdriverio/webdriverio\n\nTo run your tests, execute:\n$ cd %s\n$ npm run wdio\n";
 export declare const DEPENDENCIES_INSTALLATION_MESSAGE = "\nTo install dependencies, execute:\n%s\n";
 export declare const NPM_INSTALL = "";
 export declare const ANDROID_CONFIG: {
@@ -305,14 +305,6 @@ export declare const QUESTIONNAIRE: ({
     choices: readonly ["https", "http"];
     when: (answers: Questionnair) => boolean;
     validate?: undefined;
-} | {
-    type: string;
-    name: string;
-    message: string;
-    default: boolean;
-    when: (answers: Questionnair) => boolean;
-    choices?: undefined;
-    validate?: undefined;
 } | {
     type: string;
     name: string;
@@ -352,23 +344,23 @@ export declare const QUESTIONNAIRE: ({
     name: string;
     message: string;
     choices: readonly ["Babel (https://babeljs.io/)", "TypeScript (https://www.typescriptlang.org/)", "No!"];
-    default: () => "Babel (https://babeljs.io/)" | "TypeScript (https://www.typescriptlang.org/)" | "No!";
+    default: (answers: Questionnair) => Promise<"Babel (https://babeljs.io/)" | "TypeScript (https://www.typescriptlang.org/)" | "No!">;
     when?: undefined;
     validate?: undefined;
 } | {
     type: string;
     name: string;
     message: string;
-    default: (answers: Questionnair) => string;
-    when: (answers: Questionnair) => RegExpMatchArray | null;
+    default: boolean;
     choices?: undefined;
+    when?: undefined;
     validate?: undefined;
 } | {
     type: string;
     name: string;
     message: string;
-    default: (answers: Questionnair) => string;
-    when: (answers: Questionnair) => boolean;
+    default: (answers: Questionnair) => Promise<string>;
+    when: (answers: Questionnair) => false | RegExpMatchArray | null;
     choices?: undefined;
     validate?: undefined;
 } | {
@@ -376,8 +368,16 @@ export declare const QUESTIONNAIRE: ({
     name: string;
     message: string;
     default: boolean;
+    when: (answers: Questionnair) => boolean;
+    choices?: undefined;
+    validate?: undefined;
+} | {
+    type: string;
+    name: string;
+    message: string;
+    default: (answers: Questionnair) => Promise<string>;
+    when: (answers: Questionnair) => boolean | undefined;
     choices?: undefined;
-    when?: undefined;
     validate?: undefined;
 } | {
     type: string;

package/build/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAO,MAAM,GAAG,KAA6B,CAAA;AAE7C,eAAO,MAAM,YAAY,QAAqE,CAAA;AAE9F,eAAO,MAAM,kBAAkB;;;;;CAK9B,CAAA;AAED,eAAO,MAAM,mBAAmB,wFAI/B,CAAA;AAED,eAAO,MAAM,6BAA6B,iHAIzC,CAAA;AAED,eAAO,MAAM,iCAAiC,8CAG7C,CAAA;AAED,eAAO,MAAM,WAAW,KAAK,CAAA;AAE7B,eAAO,MAAM,cAAc;;;;CAI1B,CAAA;AAED,eAAO,MAAM,UAAU;;;;CAItB,CAAA;AAED,eAAO,MAAM,uBAAuB,iGAI1B,CAAA;AAEV,eAAO,MAAM,gBAAgB;;;;CAInB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFrB,CAAA;AAEV,eAAO,MAAM,kCAAkC,UAG9C,CAAA;AAED,eAAO,MAAM,gCAAgC;;;GAQ5C,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAK3D,CAAA;AAED,eAAO,MAAM,eAAe,0NAMlB,CAAA;AAEV,eAAO,MAAM,gBAAgB,4BAGnB,CAAA;AAEV,eAAO,MAAM,aAAa,+BAIhB,CAAA;AAEV,iBAAS,eAAe,CAAE,OAAO,EAAE,YAAY,WAE9C;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAoBqB,YAAY;;;;;;;uBAWR,YAAY;;;;;;;;oBAchB,YAAY;;;;;;;;;oBAMZ,YAAY;;;;;;;;;oBAyBZ,YAAY;;;;;;;oBAkDZ,YAAY;;;;;;;;oBAMZ,YAAY;;;;;;;uBAuBR,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAuBxC,YAAY;oBACY,YAAY;;;;;;;uBAWpC,YAAY;oBACY,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsDR,MAAM,EAAE;;IA+BzD,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C,eAAO,MAAM,GAAG,KAA6B,CAAA;AAE7C,eAAO,MAAM,YAAY,QAAqE,CAAA;AAE9F,eAAO,MAAM,kBAAkB;;;;;CAK9B,CAAA;AAED,eAAO,MAAM,mBAAmB,wFAI/B,CAAA;AAED,eAAO,MAAM,6BAA6B,4cAYzC,CAAA;AAED,eAAO,MAAM,iCAAiC,8CAG7C,CAAA;AAED,eAAO,MAAM,WAAW,KAAK,CAAA;AAE7B,eAAO,MAAM,cAAc;;;;CAI1B,CAAA;AAED,eAAO,MAAM,UAAU;;;;CAItB,CAAA;AAED,eAAO,MAAM,uBAAuB,iGAI1B,CAAA;AAEV,eAAO,MAAM,gBAAgB;;;;CAInB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFrB,CAAA;AAEV,eAAO,MAAM,kCAAkC,UAG9C,CAAA;AAED,eAAO,MAAM,gCAAgC;;;GAQ5C,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAK3D,CAAA;AAED,eAAO,MAAM,eAAe,0NAMlB,CAAA;AAEV,eAAO,MAAM,gBAAgB,4BAGnB,CAAA;AAEV,eAAO,MAAM,aAAa,+BAIhB,CAAA;AAEV,iBAAS,eAAe,CAAE,OAAO,EAAE,YAAY,WAE9C;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAoBqB,YAAY;;;;;;;uBAWR,YAAY;;;;;;;;oBAchB,YAAY;;;;;;;;;oBAMZ,YAAY;;;;;;;;;oBAyBZ,YAAY;;;;;;;oBAkDZ,YAAY;;;;;;;uBAuBR,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAcb,YAAY;;;;;;;;;;;;;;;uBAUZ,YAAY;oBACf,YAAY;;;;;;;;oBAkBZ,YAAY;;;;;;;uBAWT,YAAY;oBAKf,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BR,MAAM,EAAE;;IA+BzD,CAAA"}

package/build/constants.js

@@ -1,5 +1,5 @@
 import { createRequire } from 'node:module';
-import { validateServiceAnswers, hasFile, getDefaultFiles, convertPackageHashToObject } from './utils.js';
+import { validateServiceAnswers, detectCompiler, getDefaultFiles, convertPackageHashToObject } from './utils.js';
 const require = createRequire(import.meta.url);
 export const pkg = require('../package.json');
 export const CLI_EPILOGUE = `Documentation: https://webdriver.io\n@wdio/cli (v${pkg.version})`;
@@ -15,9 +15,17 @@ WDIO Configuration Helper
 =========================
 `;
 export const CONFIG_HELPER_SUCCESS_MESSAGE = `
-Configuration file was created successfully!
+🤖 Successfully setup project at %s 🎉
+
+Join our Gitter community and instantly find answers to your issues or queries. Or just join and say hi 👋!
+  🔗 https://gitter.im/webdriverio/webdriverio
+
+Visit the project on GitHub to report bugs 🐛 or raise feature requests 💡:
+  🔗 https://github.com/webdriverio/webdriverio
+
 To run your tests, execute:
-$ npx wdio run %swdio.conf.%s
+$ cd %s
+$ npm run wdio
 `;
 export const DEPENDENCIES_INSTALLATION_MESSAGE = `
 To install dependencies, execute:
@@ -282,18 +290,12 @@ export const QUESTIONNAIRE = [{
         message: 'Environment variable for access key',
         default: 'SAUCE_ACCESS_KEY',
         when: /* istanbul ignore next */ (answers) => answers.backend === 'In the cloud using Sauce Labs'
-    }, {
-        type: 'confirm',
-        name: 'headless',
-        message: 'Do you want to run your test on Sauce Headless? (https://saucelabs.com/products/web-testing/sauce-headless)',
-        default: false,
-        when: /* istanbul ignore next */ (answers) => answers.backend === 'In the cloud using Sauce Labs'
     }, {
         type: 'list',
         name: 'region',
         message: 'In which region do you want to run your Sauce Labs tests in?',
         choices: REGION_OPTION,
-        when: /* istanbul ignore next */ (answers) => !answers.headless && answers.backend === 'In the cloud using Sauce Labs'
+        when: /* istanbul ignore next */ (answers) => answers.backend === 'In the cloud using Sauce Labs'
     }, {
         type: 'input',
         name: 'hostname',
@@ -330,34 +332,30 @@ export const QUESTIONNAIRE = [{
         name: 'isUsingCompiler',
         message: 'Do you want to use a compiler?',
         choices: COMPILER_OPTION_ANSWERS,
-        default: /* istanbul ignore next */ () => hasFile('babel.config.js')
-            ? COMPILER_OPTIONS.babel // default to Babel
-            : hasFile('tsconfig.json')
-                ? COMPILER_OPTIONS.ts // default to TypeScript
-                : COMPILER_OPTIONS.nil // default to no compiler
+        default: /* istanbul ignore next */ (answers) => detectCompiler(answers)
+    }, {
+        type: 'confirm',
+        name: 'generateTestFiles',
+        message: 'Do you want WebdriverIO to autogenerate some test files?',
+        default: true
     }, {
         type: 'input',
         name: 'specs',
-        message: 'Where are your test specs located?',
-        default: (answers) => getDefaultFiles(answers, './test/specs/**/*'),
-        when: /* istanbul ignore next */ (answers) => answers.framework.match(/(mocha|jasmine)/)
+        message: 'Where should these files be located?',
+        default: /* istanbul ignore next */ (answers) => getDefaultFiles(answers, 'test/specs/**/*'),
+        when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.framework.match(/(mocha|jasmine)/)
     }, {
         type: 'input',
         name: 'specs',
-        message: 'Where are your feature files located?',
-        default: './features/**/*.feature',
-        when: /* istanbul ignore next */ (answers) => answers.framework.includes('cucumber')
+        message: 'Where should these feature files be located?',
+        default: (answers) => getDefaultFiles(answers, 'features/**/*.feature'),
+        when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.framework.includes('cucumber')
     }, {
         type: 'input',
         name: 'stepDefinitions',
-        message: 'Where are your step definitions located?',
-        default: (answers) => getDefaultFiles(answers, './features/step-definitions/steps'),
-        when: /* istanbul ignore next */ (answers) => answers.framework.includes('cucumber')
-    }, {
-        type: 'confirm',
-        name: 'generateTestFiles',
-        message: 'Do you want WebdriverIO to autogenerate some test files?',
-        default: true
+        message: 'Where should these step definitions be located?',
+        default: (answers) => getDefaultFiles(answers, 'features/step-definitions/steps'),
+        when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.framework.includes('cucumber')
     }, {
         type: 'confirm',
         name: 'usePageObjects',
@@ -373,8 +371,8 @@ export const QUESTIONNAIRE = [{
         name: 'pages',
         message: 'Where are your page objects located?',
         default: /* istanbul ignore next */ (answers) => (answers.framework.match(/(mocha|jasmine)/)
-            ? getDefaultFiles(answers, './test/pageobjects/**/*')
-            : getDefaultFiles(answers, './features/pageobjects/**/*')),
+            ? getDefaultFiles(answers, 'test/pageobjects/**/*')
+            : getDefaultFiles(answers, 'features/pageobjects/**/*')),
         when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.usePageObjects
     }, {
         type: 'checkbox',

package/build/templates/exampleFiles/cucumber/step_definitions/steps.js.ejs

@@ -1,4 +1,4 @@
-<%- isUsingTypeScript || isUsingBabel
+<%- isUsingTypeScript || esmSupport
     ? "import { Given, When, Then } from '@wdio/cucumber-framework';"
     : "const { Given, When, Then } = require('@wdio/cucumber-framework');" %>
 <%
@@ -6,11 +6,11 @@
  * step definition without page objects
  */
 if (usePageObjects) { %>
-<%- isUsingTypeScript || isUsingBabel
-    ? `import LoginPage from '${relativePath}/login.page';`
+<%- isUsingTypeScript || esmSupport
+    ? `import LoginPage from '${relativePath}/login.page${esmSupport ? '.js' : ''}';`
     : `const LoginPage = require('${relativePath}/login.page');` %>
-<%- isUsingTypeScript || isUsingBabel
-    ? `import SecurePage from '${relativePath}/secure.page';`
+<%- isUsingTypeScript || esmSupport
+    ? `import SecurePage from '${relativePath}/secure.page${esmSupport ? '.js' : ''}';`
     : `const SecurePage = require('${relativePath}/secure.page');` %>
 
 const pages = {

package/build/templates/exampleFiles/jasmine/example.e2e.js.ejs

@@ -3,11 +3,11 @@
  * step definition without page objects
  */
 if (usePageObjects) {
-%><%- isUsingTypeScript || isUsingBabel
-    ? `import LoginPage from  '${relativePath}/login.page';`
+%><%- isUsingTypeScript || esmSupport
+    ? `import LoginPage from '${relativePath}/login.page${esmSupport ? '.js' : ''}';`
     : `const LoginPage = require('${relativePath}/login.page');` %>
-<%- isUsingTypeScript || isUsingBabel
-    ? `import SecurePage from '${relativePath}/secure.page';`
+<%- isUsingTypeScript || esmSupport
+    ? `import SecurePage from '${relativePath}/secure.page${esmSupport ? '.js' : ''}';`
     : `const SecurePage = require('${relativePath}/secure.page');` %>
 
 describe('My Login application', () => {

package/build/templates/exampleFiles/mocha/example.e2e.js.ejs

@@ -3,11 +3,11 @@
  * test with page objects
  */
 if (usePageObjects) {
-%><%- isUsingTypeScript || isUsingBabel
-    ? `import LoginPage from  '${relativePath}/login.page'`
+%><%- isUsingTypeScript || esmSupport
+    ? `import LoginPage from '${relativePath}/login.page${esmSupport ? '.js' : ''}'`
     : `const LoginPage = require('${relativePath}/login.page')` %>
-<%- isUsingTypeScript || isUsingBabel
-    ? `import SecurePage from '${relativePath}/secure.page'`
+<%- isUsingTypeScript || esmSupport
+    ? `import SecurePage from '${relativePath}/secure.page${esmSupport ? '.js' : ''}'`
     : `const SecurePage = require('${relativePath}/secure.page')` %>
 
 describe('My Login application', () => {
@@ -57,6 +57,7 @@ const assertionStatement = preset
 import * as matchers from '@testing-library/jest-dom/matchers'
 expect.extend(matchers)
 <% } %>
+// ToDo: fix me
 <%- importStatement %>
 
 describe('<%- (preset || 'my') %> component tests', () => {