@lynxwall/cucumber-tsflow 7.1.2 → 7.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 # cucumber-tsflow
 
-Provides 'specflow' like bindings for CucumberJS 11.2.0 in TypeScript 5.8+.
+Provides 'specflow' like bindings for Cucumber-JS 12.2.0 in TypeScript 5.9+.
 
 Supports Vue3 files in cucumber tests.
 
@@ -12,6 +12,25 @@ This is a detached fork of <https://github.com/timjroberts/cucumber-js-tsflow>.
 
 This fork has been drastically modified from the original and will eventually be moved to a new project. In addition, the SpecFlow project has reached [end of life](https://reqnroll.net/news/2025/01/specflow-end-of-life-has-been-announced/), and this project will be rebranded. Further details will be provided in future updates. However, the new project will support the same functionality as cucumber-tsflow while providing additional tools and extensions.
 
+## Release Updates (7.3.0)
+
+With this release, we've finally added support for ESM Modules. For details on the new transpilers/loaders please see: [cucumber-tsflow ESM implementation](https://github.com/LynxWall/cucumber-js-tsflow/blob/master/cucumber-tsflow/src/transpilers/esm/README.md).
+
+Along with ESM support, additional updates include:
+
+- Cucumber-JS updated to version 12.2.0
+- Typescript updated to version 5.9.2
+- ts-node replaced with ts-node-maintained. For more information, please see the section titled **Node 22+ and ts-node** in the [cucumber-tsflow ESM implementation](https://github.com/LynxWall/cucumber-js-tsflow/blob/master/cucumber-tsflow/src/transpilers/esm/README.md).
+- Other package updates.
+
+## Release Updates (7.2.0)
+
+With this release, support for **Experimental Decorators** was added for backwards compatibility with any code under test that is using experimental decorators.
+
+- Cucumber-JS updated to version 11.3.0
+- New configuration parameter named **experimentalDecorators** that can be used to enable support for older experimental decorators.
+- Issue with using the companion [VS Code Extension](https://marketplace.visualstudio.com/items?itemName=lynxwall.cucumber-tsflow-vscode) has been resolved.
+
 ## Release Updates (7.1.0)
 
 With this latest release, cucumber-tsflow has been refactored to support cucumber-js version 11.2.0 along with other updates that include:
@@ -20,7 +39,6 @@ With this latest release, cucumber-tsflow has been refactored to support cucumbe
 - **API support** that implements and extends the cucumber-js API.
 - Support for Node 22 and Typescript 5.8.
   - Switched to **official Typescript Decorators** with metadata support implemented in [Typescript 5.2](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#decorator-metadata).
-    **NOTE:** Please **remove *experimentalDecorators*** from your TypeScript configuration as it is no longer supported with the update to use official decorators, which are very different.
 - Transpiler configuration updates to support node and Typescript changes.
   - Added a new section to this readme that describes [Transpilers and TypeScript](#transpilers-and-typescript) in more detail.
 
@@ -37,7 +55,11 @@ This fork of cucumber-tsflow provides the following features that extend the ori
     - **2** - Implemented scenarios are passing but there are pending, undefined or unknown scenario steps.
     - **3** - One or more scenario steps have failed.
 
-- CommonJS transpilers using either esbuild or ts-node.
+- CommonJS transpilers using either esbuild or ts-node-maintained.
+
+- [ESM loaders](https://github.com/LynxWall/cucumber-js-tsflow/blob/master/cucumber-tsflow/src/transpilers/esm/README.md) using either esbuild or ts-node-maintained.
+
+- Support for both Official and Experimental Decorators in TypeScript.
 
 - Vue3 transformer used to handle .vue files in tests.
 
@@ -69,7 +91,7 @@ This fork of cucumber-tsflow provides the following features that extend the ori
 
 ## Quick Start
 
-cucumber-tsflow uses TypeScript Decorators to create SpecFlow like bindings for TypeScript classes and methods that allow those classes and methods to be used in your CucumberJS support files. As such, cucumber-tsflow has a dependency on CucumberJS and extends CucumberJS functionality. However, you run your specifications using the cucumber-tsflow command line tool.
+cucumber-tsflow uses TypeScript Decorators to create bindings for TypeScript classes and methods that allow those classes and methods to be used in your Cucumber-JS support files. As such, cucumber-tsflow has a dependency on Cucumber-JS and extends Cucumber-JS functionality. However, you run your specifications using the cucumber-tsflow command line tool.
 
 ### Install @lynxwall/cucumber-tsflow
 
@@ -95,7 +117,7 @@ yarn add --dev @lynxwall/cucumber-tsflow
 
 ### Create .feature files to describe your specifications
 
-By default, CucumberJS looks for .feature files in a folder called 'features', so create that folder and then create a new file called 'my_feature.feature':
+By default, Cucumber-JS looks for .feature files in a folder called 'features', so create that folder and then create a new file called 'my_feature.feature':
 
 ```gherkin
 # features/my_feature.feature
@@ -111,7 +133,11 @@ Feature: Example Feature
 
 ### Create the Support Files to support the Feature
 
-By default, CucumberJS looks for support files beneath the 'features' folder. You can override this on the cucumber-tsflow command line by specifying the '-r' option. However, let's work with the default and create our code in the default location. We need to write step definitions to support the three steps that we created above.
+<div style="padding: 15px; border: 1px solid transparent; border-color: transparent; margin-bottom: 20px; border-radius: 4px; color: #8a6d3b; background-color: #fcf8e3; border-color: #faebcc;">
+<strong><span style="color: #000">Note:</span></strong> Cucumber-JS refers to any files that are used to implement tests (step definitions) along with any fixtures or utilities used in your tests as <strong><span style="color: #000">Support Files</span></strong>. As a result, any time you see references to support files or support code it is referring to test code.
+</div>
+
+By default, Cucumber-JS looks for support files beneath the 'features' folder. You can override this on the cucumber-tsflow command line by specifying the '-r' option. However, let's work with the default and create our code in the default location. We need to write step definitions to support the three steps that we created above.
 
 Create a new 'ArithmeticSteps.ts' file:
 
@@ -147,38 +173,64 @@ export default class ArithmeticSteps {
 
 ### Compiling your TypeScript Support Code
 
-If not using one of the [transpilers](#transpiler-and-vue3-supported) listed below you'll need a `tsconfig.json` file to compile your code. You'll also need to ensure that the `"moduleResolution": "node"` compiler option is set in order to bring in the typings that are shipped with cucumber-tsflow.
+All support code, which includes your step definition files along with any test fixtures, utilities and references to source code are transpiled on the fly using transpilers that are included with cucumber-tsflow. This eliminates the requirement to prebuild any test code along with associated management of those builds.
 
-Running the cucumber-tsflow command will execute your features along with the support code that you've created in the class.
-
-In this quick example test state is encapsulated directly in the class. As your test suite grows larger and step definitions get shared between multiple classes, you can begin using '[Context Injection](#context-injection)' to share state between running step definitions.
+If not using one of the [transpilers](#transpiler-and-vue3-supported) listed below you'll need to implement your own transpiler using guidance found in Cucumber-JS documentation: [Transpiling](https://github.com/cucumber/cucumber-js/blob/v12.2.0/docs/transpiling.md)
 
 ## Transpilers and TypeScript
 
 Cucumber-tsflow provides several [transpilers](#transpiler-and-vue3-supported) that can be used in your configuration. However, you are not required to use them. If a different configuration or transpiler is needed you can copy code from one of the provided transpilers.
 
-This section focuses on the Typescript configuration used to transpile your test code, and any dependencies, into JavaScript that is executed within the cucumber-js test runner.
+This section focuses on the configuration used to transpile your test code, and any dependencies, into JavaScript that is executed within the Cucumber-JS test runner.
 
 ### CommonJS and ESM
 
-The transpilers included with cucumber-tsflow transpile to **CommonJS** and do not support projects with `"type": "module"` in your `package.json`. However, [esModuleinterop](https://www.typescriptlang.org/tsconfig/#esModuleInterop) is enabled by default, which allows you to write code using ECMAScript (ESM) standards and import ESM modules in your test code.
+As of version 7.3.0, cucumber-tsflow supports projects written in both CommonJS & ESM.
+
+Read more about [cucumber-tsflow ESM implementations](./cucumber-tsflow/src/transpilers/esm/README.md).
 
 ### TypeScript Configuration
 
-All of the transpilers included with cucumber-tsflow use the same TypeScript configuration, which take precedence when running your tests using one of these transpilers. In other words, while each transpiler is different, they all use the same tsconfig settings, which are shown below:
+There are two different bundlers, or transpilers, used in cucumber-tsflow: **ts-node** and **esbuild**. This section covers the typescript configuration used for each bundler. Included with cucumber-ts are six variations of these transpilers used to support different types of projects. However, there are only two variations of typescript configurations used for each bundler, one that uses official decorators and one that uses experimental decorators.
+
+#### ts-node
+
+The following typescript configuration is used in the ts-node transpilers configured for official decorators:
 
 ```typescript
 	compilerOptions: {
 		module: 'nodeNext',
 		target: 'es2022',
 		strict: true,
-		resolveJsonModule: true,
+		allowJs: true,
+		allowSyntheticDefaultImports: true,
 		esModuleInterop: true,
+		experimentalDecorators: false,
+		resolveJsonModule: true,
 		skipLibCheck: true,
 		lib: ['es2022', 'esnext.decorators']
-	},
+	}
+```
+
+This next typescript configuration is used in the ts-node transpilers configured for official decorators:
+
+```typescript
+	compilerOptions: {
+		module: 'nodeNext',
+		target: 'es2022',
+		strict: true,
+		allowJs: true,
+		allowSyntheticDefaultImports: true,
+		esModuleInterop: true,
+		experimentalDecorators: true,
+		resolveJsonModule: true,
+		skipLibCheck: true,
+		lib: ['es2022']
+	}
 ```
 
+As you can see the only difference is the setting for experimentalDecorators and the lib imports.
+
 When test runs are started, the settings from your local tsconfig.json are loaded first and then the settings from the transpiler will override the specific settings shown above. As a result, you should use these transpilers in projects that will support these settings.
 
 For example, the settings from the cucumber-tsflow vue test project is shown below:
@@ -186,33 +238,34 @@ For example, the settings from the cucumber-tsflow vue test project is shown bel
 ```json
 	"compilerOptions": {
 		"baseUrl": ".",
+		"module": "nodeNext",
 		"target": "es2022",
-		"module": "Node18",
 		"strict": true,
-		"importHelpers": true,
-		"skipLibCheck": true,
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"useDefineForClassFields": true,
-		"inlineSourceMap": true,
 		"allowJs": true,
-		"removeComments": false,
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
 		"lib": ["es2022", "esnext.decorators"],
 		"typeRoots": ["../../node_modules/@types"]
-	},
+	}
 ```
 
-These settings are similar to the default transpiler settings, which will not cause an issue. The only change will be the module from Node18 to nodeNext. Any other settings that are not included in the transpiler default will also be applied when the transpiler is executed.
+These settings are similar to the default transpiler settings, which will not cause an issue.
 
 ### esbuild Transpilers
 
-Cucumber-tsflow provides two esbuild transpilers: one with esbuild and support for Vue using the vue-sfc transpiler, and another that only uses the esbuild transpiler. Both cucumber-tsflow transpilers use the same esbuild transpiler, which is configured to generate CommonJS, as shown below:
+<div style="padding: 15px; border: 1px solid transparent; border-color: transparent; margin-bottom: 20px; border-radius: 4px; color: #8a6d3b; background-color: #fcf8e3; border-color: #faebcc;">
+<strong><span style="color: #000">Note:</span></strong> The esbuild transpilers do not use compilerOptions from tsconfig. Instead, all of the options are configured within the esbuild module that's included with cucumber-tsflow.
+</div>
+
+Cucumber-tsflow provides two esbuild transpilers: one with esbuild and support for Vue using the vue-sfc transpiler, and another that only uses the esbuild transpiler. Both cucumber-tsflow transpilers use the same esbuild transpiler, which uses the following Common set of options:
 
 ```typescript
 const commonOptions: CommonOptions = {
 	format: 'cjs',
 	logLevel: 'info',
-	target: [`es2020`],
+	target: [`es2022`],
 	minify: false,
 	sourcemap: 'external'
 };
@@ -220,6 +273,35 @@ const commonOptions: CommonOptions = {
 
 As you can see, this also uses the same target as the typescript configuration. In addition, minify is set to false, which makes it easy to debug and step into code when running tests.
 
+In order to support both official and experimental decorators the esbuild transpiler will use different configurations based on the experimentalDecorators flag in the cucumber configuration.
+
+#### Official Decorators
+
+When using official decorators the following settings are added using the esbuild tsconfigRaw setting.
+
+```typescript
+commonOptions.tsconfigRaw = {
+	compilerOptions: {
+		importsNotUsedAsValues: 'remove',
+		strict: true
+	}
+};
+```
+
+#### Experimental Decorators
+
+When using experimental decorators the experimentalDecorators setting is added to the tsconfigRaw settings. As mentioned, esbuild does not use tsconfig settings from ts-node or from a tsconfig file. As a result, this is the only option available to turn on experimental decorators when using esbuild.
+
+```typescript
+commonOptions.tsconfigRaw = {
+	compilerOptions: {
+		experimentalDecorators: true,
+		importsNotUsedAsValues: 'remove',
+		strict: true
+	}
+};
+```
+
 As mentioned at the beginning of this section, there are several transpilers provided, which can be used with your test project. The [transpilers](#transpiler-and-vue3-supported) section below provides information on how to configure your project to use one of these transpilers.
 
 ## Cucumber-tsflow Test Runner
@@ -229,22 +311,23 @@ As mentioned previously, with recent updates cucumber-tsflow must be used to exe
 The following example demonstrates executing cucumber-tsflow from the command line to execute tests:
 
 ```bash
-C:\GitHub\cucumber-js-tsflow (dev -> origin)
-λ npx cucumber-tsflow
-Loading configuration and step definitions...
+C:\GitHub\cucumber-js-tsflow\cucumber-tsflow-specs\node (dev-0525 -> origin)
+λ npx cucumber-tsflow -p esnode
+Loading configuration from "cucumber.json".
+Running Cucumber-TsFlow in Serial mode.
 
 beforeAll was called
-......@basic after hook is called.
+......................@basic after hook is called.
 .......@basic after hook is called.
 .......@basic after hook is called.
-...........@tags1 after hook is called.
+.......................................@tags1 after hook is called.
 ......@tagging afterTag method is called
-.........<Suspense> is an experimental feature and its API will likely change.
-..afterAll was called
+.afterAll was called
+
 
-8 scenarios (8 passed)
-24 steps (24 passed)
-0m00.076s (executing steps: 0m00.040s)
+15 scenarios (15 passed)
+44 steps (44 passed)
+0m00.072s (executing steps: 0m00.013s)
 ```
 
 To recap, cucumber-tsflow extends cucumber-js, which means that all options and features provided by cucumber-js are supported with cucumber-tsflow. In other words, when executing tests using cucumber-tsflow the underlying cucumber API is actually used to run the tests.
@@ -255,7 +338,7 @@ You can also add a script to package.json to execute the tests as shown below:
 
 ```json
 "scripts": {
-	"test": "cucumber-tsflow -p default"
+	"test": "cucumber-tsflow -p esnode"
 }
 ```
 
@@ -313,36 +396,46 @@ echo $?
 
 ## New Configuration options
 
-As mentioned, when using cucumber-tsflow to execute tests all of the configuration options documented here are supported: <https://github.com/cucumber/cucumber-js/blob/v11.2.0/docs/configuration.md>
+As mentioned, when using cucumber-tsflow to execute tests all of the configuration options documented here are supported: <https://github.com/cucumber/cucumber-js/blob/v12.2.0/docs/configuration.md>
 
 In addition to cucumber configuration options the following two options have been added:
 
-| Name             | Type      | Repeatable | CLI Option           | Description                                                   | Default |
-| ---------------- | --------- | ---------- | -------------------- | ------------------------------------------------------------- | ------- |
-| `transpiler`     | `string`  | No         | `--transpiler`       | Name of the transpiler to use: esnode, esvue, tsnode or tsvue | esnode  |
-| `debugFile`      | `string`  | No         | `--debug-file`       | Path to a file with steps for debugging                       |         |
-| `enableVueStyle` | `boolean` | No         | `--enable-vue-style` | Enable Vue `<style>` block when compiling Vue SFC.            | false   |
+| Name                     | Type      | Repeatable | CLI Option                  | Description                                                  | Default |
+| ------------------------ | --------- | ---------- | --------------------------- | ------------------------------------------------------------ | ------- |
+| `transpiler`             | `string`  | No         | `--transpiler`              | Name of the transpiler to use: es-vue, ts-vue, es-node, ts-node, es-vue-esm, es-node-esm, ts-vue-esm, ts-node-esm | none    |
+| `debugFile`              | `string`  | No         | `--debug-file`              | Path to a file with steps for debugging                      |         |
+| `enableVueStyle`         | `boolean` | No         | `--enable-vue-style`        | Enable Vue `<style>` block when compiling Vue SFC.           | false   |
+| `experimentalDecorators` | `boolean` | No         | `--experimental-decorators` | Enable TypeScript Experimental Decorators.                   | false   |
 
 ### Transpiler and Vue3 supported
 
-Using TypeScript with cucumber-js requires setting tsconfig.json parameters as described here: [cucumber-js Transpiling](https://github.com/cucumber/cucumber-js/blob/v11.2.0/docs/transpiling.md). In addition, there is no support for transpiling Vue files with cucumber-js.
+Using TypeScript with cucumber-js requires setting tsconfig.json parameters as described here: [cucumber-js Transpiling](https://github.com/cucumber/cucumber-js/blob/v12.2.0/docs/transpiling.md). In addition, there is no support for transpiling Vue files with cucumber-js.
 
 As a result, cucumber-tsflow adds several configurations for transpiling TypeScript code using the recommended configuration. In addition, support has been added to transform .vue files during test execution allowing you to test Vue SFC components using cucumber.
 
-**NOTE**: By default, the `<style>` block in Vue SFC components will not be loaded when .vue files are transformed. However, that behavior can be overridden when testing compiled Vue components from a library using the `enableVueStyle` configuration setting.
+By default, the `<style>` block in Vue SFC components will not be loaded when .vue files are transformed. However, that behavior can be overridden when testing compiled Vue components from a library using the `enableVueStyle` configuration setting.
 
-The following transpilers are provided:
+Cucumber-TsFlow provides the following transpilers:
 
-- **esnode**: Uses esbuild to transpile TypeScript code for node test execution.
-- **esvue**: Uses esbuild to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into commonJS.
-  - **jsdom** is also loaded globally to support loading and testing Vue SFC components.
-- **tsnode**: Uses typescript to transpile TypeScript code for node test execution.
-- **tsvue**: Uses typescript to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into commonJS.
-  - **jsdom** is also loaded globally to support loading and testing Vue SFC components.
+| Name            | Transpiler/ Loader   | Bundler | Description                                                  |
+| --------------- | -------------------- | ------- | ------------------------------------------------------------ |
+| **es‑vue**      | esvue                | esbuild | Uses esbuild to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into common-JS. |
+| **es‑node**     | esnode               | esbuild | Uses esbuild to transpile TypeScript code for node test execution. Output is common-JS. |
+| **es‑vue‑esm**  | esvue‑loader         | esbuild | Uses esbuild to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into ESM. |
+| **es‑node‑esm** | esnode‑loader        | esbuild | Uses esbuild to transpile TypeScript code for node test execution. Output is ESM. |
+| **ts‑vue**      | tsvue or tsvue‑exp   | ts‑node | Uses ts-node to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into common-JS. |
+| **ts‑node**     | tsnode or tsnode‑exp | ts‑node | Uses ts-node to transpile TypeScript code for node test execution. Output is common-JS. |
+| **ts‑vue‑esm**  | vue‑loader           | ts-node | Uses ts-node to transpile TypeScript code and adds a hook for .vue files, which transforms Vue SFC components into ESM. |
+| **ts‑node‑esm** | tsnode‑loader        | ts-node | Uses ts-node to transpile TypeScript code for node test execution. Output is ESM. |
 
-<div style="padding: 15px; border: 1px solid transparent; border-color: transparent; margin-bottom: 20px; border-radius: 4px; color: #8a6d3b; background-color: #fcf8e3; border-color: #faebcc;">
-<strong><span style="color: #000">Note:</span></strong> The transpilers provide with cucumber-tsflow will only support CommonJS modules. In other words, if your package.json file has 'type: module' you will not be able to use these transpilers. However, you can use ts-node for transpiling as documented here: <a ref='https://github.com/cucumber/cucumber-js/blob/v11.2.0/docs/transpiling.md#esm'>Transpiling</a>
-</div>
+In the table above:
+
+- **Name** - The name that would be used in cucumber.json configuration.
+- **Transpiler/Loader** - The actual transpiler or loader (esm), that is loaded based on configuration.
+  - **NOTE**: When experimental decorators are enabled a transpiler with -exp appended to the name is loaded. For ESM builds loaders are used that use the configuration setting to determine support for experimental decorators.
+- **Bundler** - Main bundler used. ts-node (ts-node-maintained) or esbuild.
+
+**NOTE:** When using Vue transpilers **jsdom** is also loaded globally to support loading and testing Vue SFC components.
 
 ##### Using the transpiler configuration option
 
@@ -351,7 +444,7 @@ When configuring cucumber to execute tests you can specify which transpiler to u
 ```json
 {
 	"default": {
-		"transpiler": "esvue"
+		"transpiler": "es-vue"
 	}
 }
 ```
@@ -513,7 +606,7 @@ public givenAValueBasedSearch(searchValue: string): void {
 }
 ```
 
-**Note**: Tags added to steps work the same as "Tagged Hooks" documented here: <https://github.com/cucumber/cucumber-js/blob/v11.2.0/docs/support_files/hooks.md>
+**Note**: Tags added to steps work the same as "Tagged Hooks" documented here: <https://github.com/cucumber/cucumber-js/blob/v12.2.0/docs/support_files/hooks.md>
 
 ## Hooks
 
@@ -589,7 +682,7 @@ public givenAValueBasedSearch(searchValue: string): void {
 
 tsflow currently doesn't have a way to define a global default step timeout,
 
-but it can be easily done through CucumberJS `setDefaultTimeout` function.
+but it can be easily done through Cucumber-JS `setDefaultTimeout` function.
 
 ### Passing WrapperOptions
 
@@ -608,13 +701,13 @@ public givenAValueBasedSearch(searchValue: string): void {
 
 ### Using different report formatters and tsflow-snippet-syntax
 
-Changing the formatter used for generating json along with changing the Snippet Syntax can be done through the CucumberJS configuration file.
+Changing the formatter used for generating json along with changing the Snippet Syntax can be done through the Cucumber-JS configuration file.
 
 If it doesn't already exist, create a file named cucumber.json at the root of your project. This is where we can configure different options for CucumberJS.
 
 #### Using the behave json formatter
 
-The following example shows how to configure the behave formatter in cucumber.json. The tsflow-snippet-syntax module is configured as the default snippet syntax and does not require configuration. However, you can override the snippet syntax as documented here: <https://github.com/cucumber/cucumber-js/blob/v11.2.0/docs/custom_snippet_syntaxes.md>
+The following example shows how to configure the behave formatter in cucumber.json. The tsflow-snippet-syntax module is configured as the default snippet syntax and does not require configuration. However, you can override the snippet syntax as documented here: <https://github.com/cucumber/cucumber-js/blob/v12.2.0/docs/custom_snippet_syntaxes.md>
 
 ```typescript
 {

package/lib/api/convert-configuration.d.ts

@@ -0,0 +1,7 @@
+import { IConfiguration } from '@cucumber/cucumber/lib/configuration/index';
+import { ILogger } from '@cucumber/cucumber/lib/environment/index';
+import { ITsFlowRunConfiguration } from '../runtime/types';
+export interface IConfigurationExt extends IConfiguration {
+    experimentalDecorators: boolean;
+}
+export declare function convertConfiguration(logger: ILogger, flatConfiguration: IConfigurationExt, env: NodeJS.ProcessEnv): Promise<ITsFlowRunConfiguration>;

package/lib/api/convert-configuration.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfiguration = convertConfiguration;
+const index_1 = require("@cucumber/cucumber/lib/configuration/index");
+async function convertConfiguration(logger, flatConfiguration, env) {
+    return {
+        sources: {
+            paths: flatConfiguration.paths,
+            defaultDialect: flatConfiguration.language,
+            names: flatConfiguration.name,
+            tagExpression: flatConfiguration.tags,
+            order: flatConfiguration.order
+        },
+        support: {
+            requireModules: flatConfiguration.requireModule,
+            requirePaths: flatConfiguration.require,
+            importPaths: flatConfiguration.import,
+            loaders: flatConfiguration.loader
+        },
+        runtime: {
+            dryRun: flatConfiguration.dryRun,
+            experimentalDecorators: flatConfiguration.experimentalDecorators,
+            failFast: flatConfiguration.failFast,
+            filterStacktraces: !flatConfiguration.backtrace,
+            parallel: flatConfiguration.parallel,
+            retry: flatConfiguration.retry,
+            retryTagFilter: flatConfiguration.retryTagFilter,
+            strict: flatConfiguration.strict,
+            worldParameters: flatConfiguration.worldParameters
+        },
+        formats: convertFormats(logger, flatConfiguration, env)
+    };
+}
+function convertFormats(logger, flatConfiguration, env) {
+    const splitFormats = flatConfiguration.format.map(item => Array.isArray(item) ? item : (0, index_1.splitFormatDescriptor)(logger, item));
+    return {
+        stdout: [...splitFormats].reverse().find(([, target]) => !target)?.[0] ?? 'progress',
+        files: splitFormats
+            .filter(([, target]) => !!target)
+            .reduce((mapped, [type, target]) => {
+            return {
+                ...mapped,
+                [target]: type
+            };
+        }, {}),
+        publish: makePublishConfig(flatConfiguration, env),
+        options: flatConfiguration.formatOptions
+    };
+}
+function makePublishConfig(flatConfiguration, env) {
+    const enabled = isPublishing(flatConfiguration, env);
+    if (!enabled) {
+        return false;
+    }
+    return {
+        url: env.CUCUMBER_PUBLISH_URL,
+        token: env.CUCUMBER_PUBLISH_TOKEN
+    };
+}
+function isPublishing(flatConfiguration, env) {
+    return (flatConfiguration.publish ||
+        (0, index_1.isTruthyString)(env.CUCUMBER_PUBLISH_ENABLED) ||
+        env.CUCUMBER_PUBLISH_TOKEN !== undefined);
+}
+//# sourceMappingURL=convert-configuration.js.map

package/lib/api/convert-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-configuration.js","sourceRoot":"","sources":["../../src/api/convert-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import { IConfiguration, isTruthyString, splitFormatDescriptor } from '@cucumber/cucumber/lib/configuration/index';\r\nimport { IPublishConfig } from '@cucumber/cucumber/lib/publish/index';\r\nimport { ILogger } from '@cucumber/cucumber/lib/environment/index';\r\n\r\n// imports the namespace needed for NodeJS - keeps eslint happy\r\nimport NodeJS from 'node:process';\r\nimport { ITsFlowRunConfiguration } from '../runtime/types';\r\n\r\nexport interface IConfigurationExt extends IConfiguration {\r\n\texperimentalDecorators: boolean;\r\n}\r\n\r\nexport async function convertConfiguration(\r\n\tlogger: ILogger,\r\n\tflatConfiguration: IConfigurationExt,\r\n\tenv: NodeJS.ProcessEnv\r\n): Promise<ITsFlowRunConfiguration> {\r\n\treturn {\r\n\t\tsources: {\r\n\t\t\tpaths: flatConfiguration.paths,\r\n\t\t\tdefaultDialect: flatConfiguration.language,\r\n\t\t\tnames: flatConfiguration.name,\r\n\t\t\ttagExpression: flatConfiguration.tags,\r\n\t\t\torder: flatConfiguration.order\r\n\t\t},\r\n\t\tsupport: {\r\n\t\t\trequireModules: flatConfiguration.requireModule,\r\n\t\t\trequirePaths: flatConfiguration.require,\r\n\t\t\timportPaths: flatConfiguration.import,\r\n\t\t\tloaders: flatConfiguration.loader\r\n\t\t},\r\n\t\truntime: {\r\n\t\t\tdryRun: flatConfiguration.dryRun,\r\n\t\t\texperimentalDecorators: flatConfiguration.experimentalDecorators,\r\n\t\t\tfailFast: flatConfiguration.failFast,\r\n\t\t\tfilterStacktraces: !flatConfiguration.backtrace,\r\n\t\t\tparallel: flatConfiguration.parallel,\r\n\t\t\tretry: flatConfiguration.retry,\r\n\t\t\tretryTagFilter: flatConfiguration.retryTagFilter,\r\n\t\t\tstrict: flatConfiguration.strict,\r\n\t\t\tworldParameters: flatConfiguration.worldParameters\r\n\t\t},\r\n\t\tformats: convertFormats(logger, flatConfiguration, env)\r\n\t};\r\n}\r\n\r\nfunction convertFormats(logger: ILogger, flatConfiguration: IConfiguration, env: NodeJS.ProcessEnv) {\r\n\tconst splitFormats: string[][] = flatConfiguration.format.map(item =>\r\n\t\tArray.isArray(item) ? item : splitFormatDescriptor(logger, item)\r\n\t);\r\n\treturn {\r\n\t\tstdout: [...splitFormats].reverse().find(([, target]) => !target)?.[0] ?? 'progress',\r\n\t\tfiles: splitFormats\r\n\t\t\t.filter(([, target]) => !!target)\r\n\t\t\t.reduce((mapped, [type, target]) => {\r\n\t\t\t\treturn {\r\n\t\t\t\t\t...mapped,\r\n\t\t\t\t\t[target]: type\r\n\t\t\t\t};\r\n\t\t\t}, {}),\r\n\t\tpublish: makePublishConfig(flatConfiguration, env),\r\n\t\toptions: flatConfiguration.formatOptions\r\n\t};\r\n}\r\n\r\nfunction makePublishConfig(flatConfiguration: IConfiguration, env: NodeJS.ProcessEnv): IPublishConfig | false {\r\n\tconst enabled = isPublishing(flatConfiguration, env);\r\n\tif (!enabled) {\r\n\t\treturn false;\r\n\t}\r\n\treturn {\r\n\t\turl: env.CUCUMBER_PUBLISH_URL,\r\n\t\ttoken: env.CUCUMBER_PUBLISH_TOKEN\r\n\t};\r\n}\r\n\r\nfunction isPublishing(flatConfiguration: IConfiguration, env: NodeJS.ProcessEnv): boolean {\r\n\treturn (\r\n\t\tflatConfiguration.publish ||\r\n\t\tisTruthyString(env.CUCUMBER_PUBLISH_ENABLED) ||\r\n\t\tenv.CUCUMBER_PUBLISH_TOKEN !== undefined\r\n\t);\r\n}\r\n"]}

package/lib/api/index.d.ts

@@ -10,6 +10,7 @@ export { IConfiguration } from '@cucumber/cucumber/lib/configuration/index';
 export { IRunEnvironment } from '@cucumber/cucumber/lib/environment/index';
 export { IPickleOrder } from '@cucumber/cucumber/lib/filter/index';
 export { IPublishConfig } from '@cucumber/cucumber/lib/publish/index';
+export * from './convert-configuration';
 export * from './load-configuration';
 export * from '@cucumber/cucumber/lib/api/load_sources';
 export * from './load-support';

package/lib/api/index.js

@@ -22,6 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./convert-configuration"), exports);
 __exportStar(require("./load-configuration"), exports);
 __exportStar(require("@cucumber/cucumber/lib/api/load_sources"), exports);
 __exportStar(require("./load-support"), exports);

package/lib/api/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;AAMH,uDAAqC;AACrC,0EAAwD;AACxD,iDAA+B;AAC/B,iDAA+B;AAC/B,mEAAiD","sourcesContent":["/**\r\n * JavaScript API for running and extending Cucumber\r\n *\r\n * @packageDocumentation\r\n * @module api\r\n * @remarks\r\n * These docs cover the API used for running Cucumber-tsflow programmatically. The entry point is `@lynxwall/cucumber-tsflow/api`.\r\n */\r\n\r\nexport { IConfiguration } from '@cucumber/cucumber/lib/configuration/index';\r\nexport { IRunEnvironment } from '@cucumber/cucumber/lib/environment/index';\r\nexport { IPickleOrder } from '@cucumber/cucumber/lib/filter/index';\r\nexport { IPublishConfig } from '@cucumber/cucumber/lib/publish/index';\r\nexport * from './load-configuration';\r\nexport * from '@cucumber/cucumber/lib/api/load_sources';\r\nexport * from './load-support';\r\nexport * from './run-cucumber';\r\nexport * from '@cucumber/cucumber/lib/api/types';\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;AAMH,0DAAwC;AACxC,uDAAqC;AACrC,0EAAwD;AACxD,iDAA+B;AAC/B,iDAA+B;AAC/B,mEAAiD","sourcesContent":["/**\r\n * JavaScript API for running and extending Cucumber\r\n *\r\n * @packageDocumentation\r\n * @module api\r\n * @remarks\r\n * These docs cover the API used for running Cucumber-tsflow programmatically. The entry point is `@lynxwall/cucumber-tsflow/api`.\r\n */\r\n\r\nexport { IConfiguration } from '@cucumber/cucumber/lib/configuration/index';\r\nexport { IRunEnvironment } from '@cucumber/cucumber/lib/environment/index';\r\nexport { IPickleOrder } from '@cucumber/cucumber/lib/filter/index';\r\nexport { IPublishConfig } from '@cucumber/cucumber/lib/publish/index';\r\nexport * from './convert-configuration';\r\nexport * from './load-configuration';\r\nexport * from '@cucumber/cucumber/lib/api/load_sources';\r\nexport * from './load-support';\r\nexport * from './run-cucumber';\r\nexport * from '@cucumber/cucumber/lib/api/types';\r\n"]}

package/lib/api/load-configuration.d.ts

@@ -1,6 +1,7 @@
-import { ILoadConfigurationOptions, IRunConfiguration } from '@cucumber/cucumber/lib/api/types';
+import { ILoadConfigurationOptions } from '@cucumber/cucumber/lib/api/types';
 import { IRunEnvironment } from '@cucumber/cucumber/lib/environment/index';
 import { ITsflowConfiguration } from '../cli/argv-parser';
+import { ITsFlowRunConfiguration } from '../runtime/types';
 export interface ITsflowResolvedConfiguration {
     /**
      * The final flat configuration object resolved from the configuration file/profiles plus any extra provided.
@@ -9,7 +10,7 @@ export interface ITsflowResolvedConfiguration {
     /**
      * The format that can be passed into `runCucumber`.
      */
-    runConfiguration: IRunConfiguration;
+    runConfiguration: ITsFlowRunConfiguration;
 }
 /**
  * Load user-authored configuration to be used in a test run.