@wdio/cli 8.17.0 → 8.18.0

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;AAWjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIxE,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,CAoF/E,CAAA;AAED,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAoBpG;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,sBAAsB,EAAE,YAAY,0BAAmB;;;;GAQ1F;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,MAAM;;;GAMzD;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,MAAM,+BAQ3D;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,UAAQ,EAAE,YAAY,0BAAmB,8BA4BrI"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAWjC,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIxE,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,CAyF/E,CAAA;AAED,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAsBpG;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,sBAAsB,EAAE,YAAY,0BAAmB;;;;GAQ1F;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,MAAM;;;GAMzD;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,MAAM,+BAQ3D;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,UAAQ,EAAE,YAAY,0BAAmB,8BA4BrI"}

package/build/commands/config.js

@@ -1,9 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import util from 'node:util';
 import inquirer from 'inquirer';
-import { CONFIG_HELPER_INTRO, CLI_EPILOGUE, CompilerOptions, SUPPORTED_PACKAGES, CONFIG_HELPER_SUCCESS_MESSAGE, isNuxtProject, SUPPORTED_CONFIG_FILE_EXTENSION } from '../constants.js';
-import { convertPackageHashToObject, getAnswers, getPathForFileGeneration, getProjectProps, getProjectRoot, createPackageJSON, setupTypeScript, setupBabel, npmInstall, createWDIOConfig, createWDIOScript, runAppiumInstaller } from '../utils.js';
+import { CONFIG_HELPER_INTRO, CLI_EPILOGUE, CompilerOptions, SUPPORTED_PACKAGES, configHelperSuccessMessage, isNuxtProject, SUPPORTED_CONFIG_FILE_EXTENSION, CONFIG_HELPER_SERENITY_BANNER, } from '../constants.js';
+import { convertPackageHashToObject, getAnswers, getPathForFileGeneration, getProjectProps, getProjectRoot, createPackageJSON, setupTypeScript, setupBabel, npmInstall, createWDIOConfig, createWDIOScript, runAppiumInstaller, getSerenityPackages } 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.';
@@ -39,6 +38,7 @@ export const parseAnswers = async function (yes) {
     const runnerPackage = convertPackageHashToObject(answers.runner || SUPPORTED_PACKAGES.runner[0].value);
     const servicePackages = answers.services.map((service) => convertPackageHashToObject(service));
     const pluginPackages = answers.plugins.map((plugin) => convertPackageHashToObject(plugin));
+    const serenityPackages = getSerenityPackages(answers);
     const reporterPackages = answers.reporters.map((reporter) => convertPackageHashToObject(reporter));
     const presetPackage = convertPackageHashToObject(answers.preset || '');
     const projectProps = await getProjectProps(process.cwd());
@@ -49,7 +49,8 @@ export const parseAnswers = async function (yes) {
         presetPackage.package,
         ...reporterPackages.map(reporter => reporter.package),
         ...pluginPackages.map(plugin => plugin.package),
-        ...servicePackages.map(service => service.package)
+        ...servicePackages.map(service => service.package),
+        ...serenityPackages,
     ].filter(Boolean);
     /**
      * find relative paths between tests and pages
@@ -77,6 +78,7 @@ export const parseAnswers = async function (yes) {
     const wdioConfigFilename = `wdio.conf.${isUsingTypeScript ? 'ts' : 'js'}`;
     const wdioConfigPath = path.resolve(projectRootDir, wdioConfigFilename);
     return {
+        projectName: projectProps?.packageJson.name || 'Test Suite',
         // default values required in templates
         ...({
             usePageObjects: false,
@@ -89,6 +91,7 @@ export const parseAnswers = async function (yes) {
         preset: presetPackage.short,
         framework: frameworkPackage.short,
         purpose: runnerPackage.purpose,
+        serenityAdapter: frameworkPackage.package === '@serenity-js/webdriverio' && frameworkPackage.purpose,
         reporters: reporterPackages.map(({ short }) => short),
         plugins: pluginPackages.map(({ short }) => short),
         services: servicePackages.map(({ short }) => short),
@@ -104,6 +107,7 @@ export const parseAnswers = async function (yes) {
         projectRootDir,
         destSpecRootPath: parsedPaths.destSpecRootPath,
         destPageObjectRootPath: parsedPaths.destPageObjectRootPath,
+        destSerenityLibRootPath: parsedPaths.destSerenityLibRootPath,
         relativePath: parsedPaths.relativePath,
         hasRootTSConfig,
         tsConfigFilePath,
@@ -122,7 +126,11 @@ export async function runConfigCommand(parsedAnswers, useYarn, npmTag) {
     /**
      * print success message
      */
-    console.log(util.format(CONFIG_HELPER_SUCCESS_MESSAGE, parsedAnswers.projectRootDir, parsedAnswers.projectRootDir));
+    console.log(configHelperSuccessMessage({
+        projectRootDir: parsedAnswers.projectRootDir,
+        runScript: parsedAnswers.serenityAdapter ? 'serenity' : 'wdio',
+        extraInfo: parsedAnswers.serenityAdapter ? CONFIG_HELPER_SERENITY_BANNER : ''
+    }));
     await runAppiumInstaller(parsedAnswers);
 }
 export async function handler(argv, runConfigCmd = runConfigCommand) {

package/build/constants.d.ts

@@ -3,7 +3,12 @@ export declare const pkg: any;
 export declare const CLI_EPILOGUE: string;
 export declare const CONFIG_HELPER_INTRO = "\n===============================\n\uD83E\uDD16 WDIO Configuration Wizard \uD83E\uDDD9\n===============================\n";
 export declare const SUPPORTED_CONFIG_FILE_EXTENSION: string[];
-export declare const CONFIG_HELPER_SUCCESS_MESSAGE = "\n\uD83E\uDD16 Successfully setup project at %s \uD83C\uDF89\n\nJoin our Discord Community Server and instantly find answers to your issues or queries. Or just join and say hi \uD83D\uDC4B!\n  \uD83D\uDD17 https://discord.webdriver.io\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 configHelperSuccessMessage: ({ projectRootDir, runScript, extraInfo }: {
+    projectRootDir: string;
+    runScript: string;
+    extraInfo: string;
+}) => string;
+export declare const CONFIG_HELPER_SERENITY_BANNER = "\nLearn more about Serenity/JS:\n  \uD83D\uDD17 https://serenity-js.org\n";
 export declare const DEPENDENCIES_INSTALLATION_MESSAGE = "\nTo install dependencies, execute:\n%s\n";
 export declare const NPM_INSTALL = "";
 export declare const ANDROID_CONFIG: {
@@ -64,8 +69,8 @@ export declare enum BackendChoice {
     Grid = "I have my own Selenium cloud"
 }
 export declare enum ElectronBuildToolChoice {
-    ElectronForge = "Electron Forge",
-    ElectronBuilder = "electron-builder",
+    ElectronForge = "Electron Forge (https://www.electronforge.io/)",
+    ElectronBuilder = "electron-builder (https://www.electron.build/)",
     SomethingElse = "Something else"
 }
 declare enum ProtocolOptions {
@@ -90,6 +95,7 @@ export declare const BROWSER_ENVIRONMENTS: {
     value: string;
 }[];
 declare function isBrowserRunner(answers: Questionnair): boolean;
+export declare function usesSerenity(answers: Questionnair): boolean;
 export declare const isNuxtProject: boolean;
 export declare const QUESTIONNAIRE: ({
     type: string;

package/build/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAG9C,eAAO,MAAM,GAAG,KAA6B,CAAA;AAE7C,eAAO,MAAM,YAAY,QAAqE,CAAA;AAE9F,eAAO,MAAM,mBAAmB,8HAI/B,CAAA;AAED,eAAO,MAAM,+BAA+B,UAA2C,CAAA;AACvF,eAAO,MAAM,6BAA6B,ucAYzC,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,oBAAY,eAAe;IACvB,KAAK,gCAAgC;IACrC,EAAE,iDAAiD;IACnD,GAAG,QAAQ;CACd;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;CAmF9B,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;IAS5C,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAM3D,CAAA;AAED,oBAAY,aAAa;IACrB,KAAK,wBAAwB;IAC7B,UAAU,kCAAkC;IAC5C,SAAS,kCAAkC;IAC3C,YAAY,oCAAoC;IAChD,YAAY,uEAAuE;IACnF,IAAI,iCAAiC;CACxC;AAED,oBAAY,uBAAuB;IAC/B,aAAa,mBAAmB;IAChC,eAAe,qBAAqB;IACpC,aAAa,mBAAmB;CACnC;AAED,aAAK,eAAe;IAChB,KAAK,UAAU;IACf,IAAI,SAAS;CAChB;AAED,oBAAY,aAAa;IACrB,EAAE,OAAO;IACT,EAAE,OAAO;IACT,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,gBAAgB;;;GAG5B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;GAG/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;GAKhC,CAAA;AAED,iBAAS,eAAe,CAAE,OAAO,EAAE,YAAY,WAE9C;AAUD,eAAO,MAAM,aAAa,SAYzB,CAAA;AAqBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkBqB,YAAY;;;;;;;oBAYX,YAAY;;;;;;;oBAiBZ,YAAY;;;;;;;;;;;oBAOb,YAAY;;;;;;;;;;oBAgBX,YAAY;;;;;oBAQb,YAAY;;;;;;;;oBAMZ,YAAY;;;;;;;;oBAyBZ,YAAY;;;;;;oBAoDZ,YAAY;;;;;;;oBASZ,YAAY;;;;;;uBA0BR,YAAY;;;;;;;;;;uBAaxC,YAAY;uBASe,YAAY;;;;;;uBAmBZ,YAAY;oBAIf,YAAY;;;;;;uBAkCT,YAAY;oBAKf,YAAY;;;;;;;;;;;;;;;;uBAqBpC,YAAY;;;;uBAuBZ,YAAY;;;;;;;;;IA2DjC,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAG9C,eAAO,MAAM,GAAG,KAA6B,CAAA;AAE7C,eAAO,MAAM,YAAY,QAAqE,CAAA;AAE9F,eAAO,MAAM,mBAAmB,8HAI/B,CAAA;AAED,eAAO,MAAM,+BAA+B,UAA2C,CAAA;AACvF,eAAO,MAAM,0BAA0B;oBAAqE,MAAM;eAAa,MAAM;eAAa,MAAM;YAYvJ,CAAA;AAED,eAAO,MAAM,6BAA6B,8EAGzC,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,oBAAY,eAAe;IACvB,KAAK,gCAAgC;IACrC,EAAE,iDAAiD;IACnD,GAAG,QAAQ;CACd;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;CAsF9B,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;IAS5C,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAM3D,CAAA;AAED,oBAAY,aAAa;IACrB,KAAK,wBAAwB;IAC7B,UAAU,kCAAkC;IAC5C,SAAS,kCAAkC;IAC3C,YAAY,oCAAoC;IAChD,YAAY,uEAAuE;IACnF,IAAI,iCAAiC;CACxC;AAED,oBAAY,uBAAuB;IAC/B,aAAa,mDAAmD;IAChE,eAAe,mDAAmD;IAClE,aAAa,mBAAmB;CACnC;AAED,aAAK,eAAe;IAChB,KAAK,UAAU;IACf,IAAI,SAAS;CAChB;AAED,oBAAY,aAAa;IACrB,EAAE,OAAO;IACT,EAAE,OAAO;IACT,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,gBAAgB;;;GAG5B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;GAG/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;GAKhC,CAAA;AAED,iBAAS,eAAe,CAAE,OAAO,EAAE,YAAY,WAE9C;AAED,wBAAgB,YAAY,CAAE,OAAO,EAAE,YAAY,WAElD;AAMD,eAAO,MAAM,aAAa,SAYzB,CAAA;AAqBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkBqB,YAAY;;;;;;;oBAYX,YAAY;;;;;;;oBAWZ,YAAY;;;;;;;;;;;oBAOb,YAAY;;;;;;;;;;oBAgBX,YAAY;;;;;oBAQb,YAAY;;;;;;;;oBAMZ,YAAY;;;;;;;;oBAyBZ,YAAY;;;;;;oBAoDZ,YAAY;;;;;;;oBASZ,YAAY;;;;;;uBA0BR,YAAY;;;;;;;;;;uBAaxC,YAAY;uBASe,YAAY;;;;;;uBAmBZ,YAAY;oBAIf,YAAY;;;;;;uBAuCT,YAAY;oBAKf,YAAY;;;;;;;;;;;;;;;;uBAiCpC,YAAY;;;;uBAuBZ,YAAY;;;;;;;;;IA2DjC,CAAA"}

package/build/constants.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { detectCompiler, getDefaultFiles, convertPackageHashToObject } from './utils.js';
+import { detectCompiler, getDefaultFiles, convertPackageHashToObject, getProjectProps, getProjectRoot, } 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})`;
@@ -11,18 +11,22 @@ export const CONFIG_HELPER_INTRO = `
 ===============================
 `;
 export const SUPPORTED_CONFIG_FILE_EXTENSION = ['js', 'ts', 'mjs', 'mts', 'cjs', 'cts'];
-export const CONFIG_HELPER_SUCCESS_MESSAGE = `
-🤖 Successfully setup project at %s 🎉
+export const configHelperSuccessMessage = ({ projectRootDir, runScript, extraInfo = '' }) => `
+🤖 Successfully setup project at ${projectRootDir} 🎉
 
 Join our Discord Community Server and instantly find answers to your issues or queries. Or just join and say hi 👋!
   🔗 https://discord.webdriver.io
 
 Visit the project on GitHub to report bugs 🐛 or raise feature requests 💡:
   🔗 https://github.com/webdriverio/webdriverio
-
+${extraInfo}
 To run your tests, execute:
-$ cd %s
-$ npm run wdio
+$ cd ${projectRootDir}
+$ npm run ${runScript}
+`;
+export const CONFIG_HELPER_SERENITY_BANNER = `
+Learn more about Serenity/JS:
+  🔗 https://serenity-js.org
 `;
 export const DEPENDENCIES_INSTALLATION_MESSAGE = `
 To install dependencies, execute:
@@ -59,8 +63,11 @@ export const SUPPORTED_PACKAGES = {
     ],
     framework: [
         { name: 'Mocha (https://mochajs.org/)', value: '@wdio/mocha-framework$--$mocha' },
+        { name: 'Mocha with Serenity/JS (https://serenity-js.org/)', value: '@serenity-js/webdriverio$--$@serenity-js/webdriverio$--$mocha' },
         { name: 'Jasmine (https://jasmine.github.io/)', value: '@wdio/jasmine-framework$--$jasmine' },
-        { name: 'Cucumber (https://cucumber.io/)', value: '@wdio/cucumber-framework$--$cucumber' }
+        { name: 'Jasmine with Serenity/JS (https://serenity-js.org/)', value: '@serenity-js/webdriverio$--$@serenity-js/webdriverio$--$jasmine' },
+        { name: 'Cucumber (https://cucumber.io/)', value: '@wdio/cucumber-framework$--$cucumber' },
+        { name: 'Cucumber with Serenity/JS (https://serenity-js.org/)', value: '@serenity-js/webdriverio$--$@serenity-js/webdriverio$--$cucumber' },
     ],
     reporter: [
         { name: 'spec', value: '@wdio/spec-reporter$--$spec' },
@@ -161,8 +168,8 @@ export var BackendChoice;
 })(BackendChoice || (BackendChoice = {}));
 export var ElectronBuildToolChoice;
 (function (ElectronBuildToolChoice) {
-    ElectronBuildToolChoice["ElectronForge"] = "Electron Forge";
-    ElectronBuildToolChoice["ElectronBuilder"] = "electron-builder";
+    ElectronBuildToolChoice["ElectronForge"] = "Electron Forge (https://www.electronforge.io/)";
+    ElectronBuildToolChoice["ElectronBuilder"] = "electron-builder (https://www.electron.build/)";
     ElectronBuildToolChoice["SomethingElse"] = "Something else";
 })(ElectronBuildToolChoice || (ElectronBuildToolChoice = {}));
 var ProtocolOptions;
@@ -193,12 +200,12 @@ export const BROWSER_ENVIRONMENTS = [
 function isBrowserRunner(answers) {
     return answers.runner === SUPPORTED_PACKAGES.runner[1].value;
 }
+export function usesSerenity(answers) {
+    return answers.framework.includes('serenity-js');
+}
 function getTestingPurpose(answers) {
     return convertPackageHashToObject(answers.runner).purpose;
 }
-function electronBuilderConfigIsJson(answers) {
-    return answers.electronBuilderConfigPath?.endsWith('.json');
-}
 export const isNuxtProject = await Promise.all([
     path.join(process.cwd(), 'nuxt.config.js'),
     path.join(process.cwd(), 'nuxt.config.ts'),
@@ -250,17 +257,11 @@ export const QUESTIONNAIRE = [{
         message: 'Which tool are you using to build your Electron app?',
         choices: Object.values(ElectronBuildToolChoice),
         when: /* instanbul ignore next */ (answers) => getTestingPurpose(answers) === 'electron'
-    }, {
-        type: 'input',
-        name: 'electronBuilderConfigPath',
-        message: 'What is the path to your electron-builder configuration?',
-        default: `${process.cwd()}/package.json`,
-        when: /* instanbul ignore next */ (answers) => getTestingPurpose(answers) === 'electron' && answers.electronBuildTool === ElectronBuildToolChoice.ElectronBuilder
     }, {
         type: 'input',
         name: 'electronAppBinaryPath',
         message: 'What is the path to the binary of your built Electron app?',
-        when: /* istanbul ignore next */ (answers) => getTestingPurpose(answers) === 'electron' && (answers.electronBuildTool !== ElectronBuildToolChoice.ElectronBuilder || !electronBuilderConfigIsJson(answers))
+        when: /* istanbul ignore next */ (answers) => getTestingPurpose(answers) === 'electron' && (answers.electronBuildTool === ElectronBuildToolChoice.SomethingElse)
     }, {
         type: 'list',
         name: 'backend',
@@ -441,7 +442,7 @@ export const QUESTIONNAIRE = [{
     }, {
         type: 'input',
         name: 'specs',
-        message: 'Where should these files be located?',
+        message: 'What should be the location of your spec files?',
         default: /* istanbul ignore next */ (answers) => {
             const pattern = isBrowserRunner(answers) ? 'src/**/*.test' : 'test/specs/**/*';
             return getDefaultFiles(answers, pattern);
@@ -450,13 +451,13 @@ export const QUESTIONNAIRE = [{
     }, {
         type: 'input',
         name: 'specs',
-        message: 'Where should these feature files be located?',
+        message: 'What should be the location of your feature files?',
         default: (answers) => getDefaultFiles(answers, 'features/**/*.feature'),
         when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.framework.includes('cucumber')
     }, {
         type: 'input',
         name: 'stepDefinitions',
-        message: 'Where should these step definitions be located?',
+        message: 'What should be the location of your step definitions?',
         default: (answers) => getDefaultFiles(answers, 'features/step-definitions/steps'),
         when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.framework.includes('cucumber')
     }, {
@@ -473,7 +474,12 @@ export const QUESTIONNAIRE = [{
              * and also not needed when running VS Code tests since the service comes with
              * its own page object implementation, nor when running Electron or MacOS tests
              */
-            !['vscode', 'electron', 'macos'].includes(getTestingPurpose(answers)))
+            !['vscode', 'electron', 'macos'].includes(getTestingPurpose(answers)) &&
+            /**
+             * Serenity/JS generates Lean Page Objects by default, so there's no need to ask about it
+             * See https://serenity-js.org/handbook/web-testing/page-objects-pattern/
+             */
+            !usesSerenity(answers))
     }, {
         type: 'input',
         name: 'pages',
@@ -482,6 +488,17 @@ export const QUESTIONNAIRE = [{
             ? getDefaultFiles(answers, 'test/pageobjects/**/*')
             : getDefaultFiles(answers, 'features/pageobjects/**/*')),
         when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && answers.usePageObjects
+    }, {
+        type: 'input',
+        name: 'serenityLibPath',
+        message: 'What should be the location of your Serenity/JS Screenplay Pattern library?',
+        default: /* istanbul ignore next */ async (answers) => {
+            const projectProps = await getProjectProps();
+            const projectRootDir = getProjectRoot(answers, projectProps);
+            const specsDir = path.resolve(projectRootDir, path.dirname(answers.specs || '').replace(/\*\*$/, ''));
+            return path.resolve(specsDir, '..', 'serenity');
+        },
+        when: /* istanbul ignore next */ (answers) => answers.generateTestFiles && usesSerenity(answers)
     }, {
         type: 'checkbox',
         name: 'reporters',

package/build/templates/EjsHelpers.d.ts

@@ -0,0 +1,18 @@
+export interface EjsHelpersConfig {
+    useEsm?: boolean;
+    useTypeScript?: boolean;
+}
+export declare class EjsHelpers {
+    readonly useTypeScript: boolean;
+    readonly useEsm: boolean;
+    constructor(config: EjsHelpersConfig);
+    if(condition: boolean, trueValue: string, falseValue?: string): string;
+    ifTs: (trueValue: string, falseValue?: string) => string;
+    ifEsm: (trueValue: string, falseValue?: string) => string;
+    param(name: string, type: string): string;
+    returns(type: string): string;
+    import(exports: string, moduleId: string): string;
+    private modulePathFrom;
+    export(keyword: 'class' | 'function' | 'const' | 'let', name: string): string;
+}
+//# sourceMappingURL=EjsHelpers.d.ts.map

package/build/templates/EjsHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EjsHelpers.d.ts","sourceRoot":"","sources":["../../src/templates/EjsHelpers.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,UAAU;IACnB,SAAgB,aAAa,EAAE,OAAO,CAAA;IACtC,SAAgB,MAAM,EAAE,OAAO,CAAA;gBAEnB,MAAM,EAAE,gBAAgB;IAKpC,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAE,MAAW;IAMjE,IAAI,cAAe,MAAM,eAAc,MAAM,YACS;IAEtD,KAAK,cAAe,MAAM,eAAc,MAAM,YACC;IAE/C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAMhC,OAAO,CAAC,IAAI,EAAE,MAAM;IAMpB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAkBxC,OAAO,CAAC,cAAc;IAYtB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,EAAE,IAAI,EAAE,MAAM;CAevE"}

package/build/templates/EjsHelpers.js

@@ -0,0 +1,59 @@
+export class EjsHelpers {
+    useTypeScript;
+    useEsm;
+    constructor(config) {
+        this.useTypeScript = config.useTypeScript ?? false;
+        this.useEsm = config.useEsm ?? false;
+    }
+    if(condition, trueValue, falseValue = '') {
+        return condition
+            ? trueValue
+            : falseValue;
+    }
+    ifTs = (trueValue, falseValue = '') => this.if(this.useTypeScript, trueValue, falseValue);
+    ifEsm = (trueValue, falseValue = '') => this.if(this.useEsm, trueValue, falseValue);
+    param(name, type) {
+        return this.useTypeScript
+            ? `${name}: ${type}`
+            : name;
+    }
+    returns(type) {
+        return this.useTypeScript
+            ? `: ${type}`
+            : '';
+    }
+    import(exports, moduleId) {
+        const individualExports = exports.split(',').map(id => id.trim());
+        const imports = this.useTypeScript
+            ? individualExports
+            : individualExports.filter(id => !id.startsWith('type '));
+        if (!imports.length) {
+            return '';
+        }
+        const modulePath = this.modulePathFrom(moduleId);
+        return this.useEsm || this.useTypeScript
+            ? `import { ${imports.join(', ')} } from '${modulePath}'`
+            : `const { ${imports.join(', ')} } = require('${modulePath}')`;
+    }
+    modulePathFrom(moduleId) {
+        if (!(moduleId.startsWith('.') && this.useEsm)) {
+            return moduleId;
+        }
+        if (moduleId.endsWith('/') && this.useEsm) {
+            return moduleId + 'index.js';
+        }
+        return moduleId + '.js';
+    }
+    export(keyword, name) {
+        if (this.useTypeScript) {
+            return `export ${keyword} ${name}`;
+        }
+        if (this.useEsm) {
+            return `export ${keyword} ${name}`;
+        }
+        if (['class', 'function'].includes(keyword)) {
+            return `module.exports.${name} = ${keyword} ${name}`;
+        }
+        return `module.exports.${name}`;
+    }
+}

package/build/templates/EjsHelpers.ts

@@ -0,0 +1,84 @@
+export interface EjsHelpersConfig {
+    useEsm?: boolean;
+    useTypeScript?: boolean;
+}
+
+export class EjsHelpers {
+    public readonly useTypeScript: boolean
+    public readonly useEsm: boolean
+
+    constructor(config: EjsHelpersConfig) {
+        this.useTypeScript = config.useTypeScript ?? false
+        this.useEsm = config.useEsm ?? false
+    }
+
+    if(condition: boolean, trueValue: string, falseValue: string = '') {
+        return condition
+            ? trueValue
+            : falseValue
+    }
+
+    ifTs = (trueValue: string, falseValue: string = '') =>
+        this.if(this.useTypeScript, trueValue, falseValue)
+
+    ifEsm = (trueValue: string, falseValue: string = '') =>
+        this.if(this.useEsm, trueValue, falseValue)
+
+    param(name: string, type: string) {
+        return this.useTypeScript
+            ? `${ name }: ${ type }`
+            : name
+    }
+
+    returns(type: string) {
+        return this.useTypeScript
+            ? `: ${ type }`
+            : ''
+    }
+
+    import(exports: string, moduleId: string) {
+        const individualExports = exports.split(',').map(id => id.trim())
+
+        const imports: string[] = this.useTypeScript
+            ? individualExports
+            : individualExports.filter(id => ! id.startsWith('type '))
+
+        if (! imports.length) {
+            return ''
+        }
+
+        const modulePath = this.modulePathFrom(moduleId)
+
+        return this.useEsm || this.useTypeScript
+            ? `import { ${ imports.join(', ') } } from '${ modulePath }'`
+            : `const { ${ imports.join(', ') } } = require('${ modulePath }')`
+    }
+
+    private modulePathFrom(moduleId: string) {
+        if (! (moduleId.startsWith('.') && this.useEsm)) {
+            return moduleId
+        }
+
+        if (moduleId.endsWith('/') && this.useEsm) {
+            return moduleId + 'index.js'
+        }
+
+        return moduleId + '.js'
+    }
+
+    export(keyword: 'class' | 'function' | 'const' | 'let', name: string) {
+        if (this.useTypeScript) {
+            return `export ${ keyword } ${ name }`
+        }
+
+        if (this.useEsm) {
+            return `export ${ keyword } ${ name }`
+        }
+
+        if (['class', 'function'].includes(keyword)) {
+            return `module.exports.${ name } = ${ keyword } ${ name }`
+        }
+
+        return `module.exports.${ name }`
+    }
+}

package/build/templates/exampleFiles/serenity-js/common/config/serenity.properties.ejs

@@ -0,0 +1 @@
+serenity.project.name=<%= answers.projectName %>

package/build/templates/exampleFiles/serenity-js/common/serenity/github-api/GitHubStatus.ts.ejs

@@ -0,0 +1,41 @@
+<%- _.import('Ensure, equals', '@serenity-js/assertions' ) %>
+<%- _.import('Task', '@serenity-js/core' ) %>
+<%- _.import('GetRequest, LastResponse, Send', '@serenity-js/rest' ) %>
+
+/**
+ * Learn more about API testing with Serenity/JS
+ *  https://serenity-js.org/handbook/api-testing/
+ */
+<%- _.export('class', 'GitHubStatus') %> {
+    static #baseApiUrl = 'https://www.githubstatus.com/api/v2/'
+    static #statusJson = this.#baseApiUrl + 'status.json'
+
+    static ensureAllSystemsOperational = () =>
+        Task.where(`#actor ensures all GitHub systems are operational`,
+            Send.a(GetRequest.to(this.#statusJson)),
+            Ensure.that(LastResponse.status(), equals(200)),
+            Ensure.that(
+                LastResponse.body<%- _.ifTs('<StatusResponse>') %>().status.description.describedAs('GitHub Status'),
+                equals('All Systems Operational')
+            ),
+        )
+}
+<% if (_.useTypeScript) { %>
+/**
+ * Interfaces describing a simplified response structure returned by the GitHub Status Summary API:
+ *  https://www.githubstatus.com/api/v2/summary.json
+ */
+interface StatusResponse {
+    page: {
+        id: string
+        name: string
+        url: string
+        time_zone: string
+        updated_at: string
+    }
+    status: {
+        indicator: string
+        description: string
+    }
+}
+<% } %>

package/build/templates/exampleFiles/serenity-js/common/serenity/todo-list-app/TodoList.ts.ejs

@@ -0,0 +1,100 @@
+<%- _.import('contain, Ensure, equals, includes, isGreaterThan', '@serenity-js/assertions') %>
+<%- _.import('type Answerable, Check, d, type QuestionAdapter, Task, Wait', '@serenity-js/core') %>
+<%- _.import('By, Enter, ExecuteScript, isVisible, Key, Navigate, Page, PageElement, PageElements, Press, Text', '@serenity-js/web') %>
+
+<%- _.import('TodoListItem', './TodoListItem') %>
+
+<%- _.export('class', 'TodoList') %> {
+
+    // Public API captures the business domain-focused tasks
+    // that an actor interacting with a TodoList app can perform
+
+    static createEmptyList = () =>
+        Task.where('#actor creates an empty todo list',
+            Navigate.to('https://todo-app.serenity-js.org/'),
+            Ensure.that(
+                Page.current().title().describedAs('website title'),
+                equals('Serenity/JS TodoApp'),
+            ),
+            Wait.until(this.#newTodoInput(), isVisible()),
+            this.#emptyLocalStorageIfNeeded(),
+        )
+
+    static #emptyLocalStorageIfNeeded = () =>
+        Task.where('#actor empties local storage if needed',
+            Check.whether(this.#persistedItems().length, isGreaterThan(0))
+                .andIfSo(
+                    this.#emptyLocalStorage(),
+                    Page.current().reload(),
+                )
+        )
+
+    static createListContaining = (<%- _.param('itemNames', 'Array<Answerable<string>>') %>) =>
+        Task.where(`#actor starts with a list containing ${ itemNames.length } items`,
+            TodoList.createEmptyList(),
+            ...itemNames.map(itemName => this.recordItem(itemName))
+        )
+
+    static recordItem = (<%- _.param('itemName', 'Answerable<string>') %>) =>
+        Task.where(d `#actor records an item called ${ itemName }`,
+            Enter.theValue(itemName).into(this.#newTodoInput()),
+            Press.the(Key.Enter).in(this.#newTodoInput()),
+            Wait.until(Text.ofAll(this.#items()), contain(itemName)),
+        )
+
+    static markAsCompleted = (<%- _.param('itemNames', 'Array<Answerable<string>>') %>) =>
+        Task.where(d`#actor marks the following items as completed: ${ itemNames }`,
+            ...itemNames.map(itemName => TodoListItem.markAsCompleted(this.#itemCalled(itemName)))
+        )
+
+    static markAsOutstanding = (<%- _.param('itemNames', 'Array<Answerable<string>>') %>) =>
+        Task.where(d`#actor marks the following items as outstanding: ${ itemNames }`,
+            ...itemNames.map(itemName => TodoListItem.markAsOutstanding(this.#itemCalled(itemName)))
+        )
+
+    static outstandingItemsCount = () =>
+        Text.of(PageElement.located(By.tagName('strong')).of(this.#outstandingItemsLabel()))
+            .as(Number)
+            .describedAs('number of items left')
+
+    // Private API captures ways to locate interactive elements and data transformation logic.
+    // Private API supports the public API and is not used in the test scenario directly.
+
+    static #itemCalled = (<%- _.param('name', 'Answerable<string>') %>) =>
+        this.#items()
+            .where(Text, includes(name))
+            .first()
+            .describedAs(d`an item called ${ name }`)
+
+    static #outstandingItemsLabel = () =>
+        PageElement.located(By.css('.todo-count'))
+            .describedAs('items left counter')
+
+    static #newTodoInput = () =>
+        PageElement.located(By.css('.new-todo'))
+            .describedAs('"What needs to be done?" input box')
+
+    static #items = () =>
+        PageElements.located(By.css('.todo-list li'))
+            .describedAs('displayed items')
+
+    static #persistedItems = () =>
+        Page.current()
+            .executeScript(`
+            return window.localStorage['serenity-js-todo-app']
+                ? JSON.parse(window.localStorage['serenity-js-todo-app'])
+                : []
+        `).describedAs('persisted items')<%- _.ifTs(' as QuestionAdapter<PersistedTodoItem[]>') %>
+
+    static #emptyLocalStorage = () =>
+        Task.where('#actor empties local storage',
+            ExecuteScript.sync(`window.localStorage.removeItem('serenity-js-todo-app')`)
+        )
+}
+<% if (_.useTypeScript) { %>
+interface PersistedTodoItem {
+    id: number;
+    name: string;
+    completed: boolean;
+}
+<% } %>

package/build/templates/exampleFiles/serenity-js/common/serenity/todo-list-app/TodoListItem.ts.ejs

@@ -0,0 +1,36 @@
+<%- _.import('contain, not', '@serenity-js/assertions') %>
+<%- _.import('Check, d, type QuestionAdapter, Task', '@serenity-js/core') %>
+<%- _.import('By, Click, CssClasses, PageElement', '@serenity-js/web') %>
+
+<%- _.export('class', 'TodoListItem') %> {
+
+    // Public API captures the business domain-focused tasks
+    // that an actor interacting with a TodoListItem app can perform
+
+    static markAsCompleted = (<%- _.param('item', 'QuestionAdapter<PageElement>') %>) =>
+        Task.where(d `#actor marks ${ item } as completed`,
+            Check.whether(CssClasses.of(item), not(contain('completed')))
+                .andIfSo(this.toggle(item)),
+        )
+
+    static markAsOutstanding = (<%- _.param('item', 'QuestionAdapter<PageElement>') %>) =>
+        Task.where(d `#actor marks ${ item } as outstanding`,
+            Check.whether(CssClasses.of(item), contain('completed'))
+                .andIfSo(this.toggle(item)),
+        )
+
+    static toggle = (<%- _.param('item', 'QuestionAdapter<PageElement>') %>) =>
+        Task.where(d `#actor toggles the completion status of ${ item }`,
+            Click.on(
+                this.#toggleButton().of(item),
+            ),
+        )
+
+    // Private API captures ways to locate interactive elements and data transformation logic.
+    // Private API supports the public API and is not used in the test scenario directly.
+
+    static #toggleButton = () =>
+        PageElement
+            .located(By.css('input.toggle'))
+            .describedAs('toggle button')
+}

package/build/templates/exampleFiles/serenity-js/cucumber/step-definitions/steps.ts.ejs

@@ -0,0 +1,37 @@
+<%- _.import('Given, When, Then, type DataTable', '@cucumber/cucumber') %>
+<%- _.import('Ensure, equals', '@serenity-js/assertions') %>
+<%- _.import('type Actor', '@serenity-js/core') %>
+<%- _.import('TodoList', '../../serenity/todo-list-app/TodoList') %>
+
+Given('{actor} starts/started with a list containing:', async (<%- _.param('actor', 'Actor') %>, <%- _.param('table', 'DataTable') %>) => {
+    await actor.attemptsTo(
+        TodoList.createListContaining(itemsFrom(table)),
+    )
+})
+
+When('{pronoun} marks/marked the following item(s) as completed:', async (<%- _.param('actor', 'Actor') %>, <%- _.param('table', 'DataTable') %>) => {
+    await actor.attemptsTo(
+        TodoList.markAsCompleted(itemsFrom(table)),
+    )
+})
+
+When('{pronoun} marks/marked the following item(s) as outstanding:', async (<%- _.param('actor', 'Actor') %>, <%- _.param('table', 'DataTable') %>) => {
+    await actor.attemptsTo(
+        TodoList.markAsOutstanding(itemsFrom(table)),
+    )
+})
+
+Then('{pronoun} should see that she has {int} item(s) outstanding', async (<%- _.param('actor', 'Actor') %>, <%- _.param('expectedCount', 'number') %>) => {
+    await actor.attemptsTo(
+        Ensure.that(TodoList.outstandingItemsCount(), equals(expectedCount)),
+    )
+})
+
+/**
+ * Extracts the data from a single-column Cucumber DataTable and returns it as an `Array<string>`
+ *
+ * @param table
+ */
+function itemsFrom(<%- _.param('table', 'DataTable') %>)<%- _.returns('string[]') %> {
+    return table.raw().map(row => row[0])
+}