@lynxwall/cucumber-tsflow 7.5.5 → 7.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 # cucumber-tsflow
 
-Provides 'specflow' like bindings for Cucumber-JS 12.2.0 in TypeScript 5.9+.
+Provides 'specflow' like bindings for Cucumber-JS 12.7.0 in TypeScript 5.9+.
 
 Supports Vue3 files in cucumber tests.
 
@@ -12,13 +12,63 @@ 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.7.0)
+
+This release focuses on correctness, performance, and code quality improvements across the codebase.
+
+### Bug Fixes
+
+- **`throw error()` in `test-case-runner.ts`** — four instances used `console.error()` (which returns `void`) instead of `new Error()`, meaning thrown errors were always `undefined`.
+- **Broken `escapeRegExp` in `runtime/utils.ts`** — the function was a no-op and double-processed intentionally constructed regex syntax. Removed entirely.
+- **Missing hook failure checks in serial adapter** — `runBeforeAllHooks()` and `runAfterAllHooks()` return values were ignored. Added failure propagation so hook errors are reported correctly.
+- **Package exports typo** — trailing apostrophe on the `esbuild-transpiler` export key.
+- **Misspelled folder name** — renamed `step-definition-snippit-syntax` to `step-definition-snippet-syntax` and updated all import references.
+
+### New Features
+
+- **Parallel preload** (`parallelLoad` configuration option) — warms transpiler on-disk caches in parallel `worker_threads` before the main support-code load phase. Each worker loads a subset of support files, triggering transpilation and populating the filesystem cache. The main thread's subsequent load (and any parallel child processes) then hit warm caches, significantly reducing startup time for large projects. Set `parallelLoad: true` for automatic thread count or provide an explicit number.
+
+### Performance and Efficiency
+
+- **Replaced `underscore` with native methods** — removed all `_.map()`, `_.flatten()`, and `_.filter()` calls in favour of native `Array.prototype` equivalents.
+- **O(1) binding lookup** — added a `Map` index to `BindingRegistry` for constant-time `getStepBindingByCucumberKey()` and `hasBindingForKey()` lookups, replacing linear scans.
+- **Collapsed `updateSupportCodeLibrary` switch** — replaced a 9-case `switch` with a lookup map.
+- **Simplified constructor injection** — replaced a 10-case `switch` in `ManagedScenarioContext` with a single spread call, removing the previous limit of nine context objects.
+- **Extracted `replaceFormatAlias` helper** — deduplicated two identical format-replacement loops in `load-configuration.ts`.
+
+### Removed
+
+- `underscore` runtime dependency and `@types/underscore` dev dependency.
+- Empty `src/support_code_library_builder/` directory.
+- Legacy `tslint:disable` comments.
+
+### Documentation
+
+- Added `Architecture.md` describing the project's architectural design, execution flow, and component relationships.
+
+## Release Updates (7.6.0)
+
+This release adds a new API function for incremental support-code reloading and consolidates the internal Vue SFC compiler.
+
+### `reloadSupport` API
+
+- **`reloadSupport(options, changedPaths, environment?)`** — evicts only the changed files (and their dependents) from Node's `require.cache`, then re-requires all support files. Unchanged files resolve instantly from transpiler cache; only changed files pay the full compilation cost. Pass an empty `changedPaths` array to evict and reload all support modules.
+- Designed for use by persistent worker processes such as the companion [VS Code Extension](https://marketplace.visualstudio.com/items?itemName=lynxwall.cucumber-tsflow-vscode), which can call `reloadSupport` when a step file is saved instead of doing a full `loadSupport` on every run.
+
+### Vue SFC compiler consolidation
+
+- The CJS Vue SFC compiler (previously a 9-file Vite-plugin-derived implementation in `vue-sfc/`) has been replaced by a single shared `vue-sfc-compiler.ts` that both the CJS transpilers and the ESM loaders delegate to.
+- Removed the `rollup` and `@rollup/pluginutils` dependencies, which were only used by the old CJS implementation.
+- Fixed a bug where image assets referenced in Vue templates (e.g. `<img src="...">`) caused a `SyntaxError: Invalid or unexpected token` in CJS mode. Asset URL transforms are now disabled — `src` attributes remain as literal strings, which is the correct behaviour for unit testing Vue components with `@vue/test-utils`.
+- Fixed duplicate **"Using Experimental Decorators."** console message that appeared twice when `experimentalDecorators: true` was set.
+
 ## 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
+- Cucumber-JS updated to version 12.2.0 (later updated to 12.7.0 in 7.7.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.
@@ -75,6 +125,8 @@ This fork of cucumber-tsflow provides the following features that extend the ori
 
 - Support for Parallel execution of tests.
 
+- Parallel preload of transpiler caches via the `parallelLoad` configuration option, reducing startup time for large projects.
+
 - A behave-json-formatter that fixes json so it can be used with Behave Pro.
 
 - A junit-bamboo formatter that generates xml compatible with the Bamboo JUnit plugin.
@@ -126,9 +178,9 @@ Feature: Example Feature
    This is an example feature
 
    Scenario: Adding two numbers
-	  Given I enter 2 and 8
-	  When checking the results
-	  Then I receive the result 10
+   Given I enter 2 and 8
+   When checking the results
+   Then I receive the result 10
 ```
 
 ### Create the Support Files to support the Feature
@@ -144,27 +196,27 @@ Create a new 'ArithmeticSteps.ts' file:
 ```javascript
 // features/ArithmeticSteps.ts
 
-import { binding, given, then } from "@lynxwall/cucumber-tsflow";
+import { binding, given, when, then } from "@lynxwall/cucumber-tsflow";
 
 @binding()
 export default class ArithmeticSteps {
     private computedResult = 0;
 
-	@given('I enter {int} and {int}')
-	iEnterintAndint(int: number, int2: number): any {
-		this.computedResult = int + int2;
+ @given('I enter {int} and {int}')
+ iEnterintAndint(int: number, int2: number): any {
+  this.computedResult = int + int2;
     }
 
-	@when('checking the results')
-	checkingTheResults(): any {
-		expect(this.computedResult).to.be.greaterThan(0);
-	}
+ @when('checking the results')
+ checkingTheResults(): any {
+  expect(this.computedResult).to.be.greaterThan(0);
+ }
 
-	@then('I receive the result {int}')
-	iReceiveTheResultint(int: number): any {
-		if (int !== this.computedResult) {
-			throw new Error('Arithmetic Error');
-		}
+ @then('I receive the result {int}')
+ iReceiveTheResultint(int: number): any {
+  if (int !== this.computedResult) {
+   throw new Error('Arithmetic Error');
+  }
     }
 }
 ```
@@ -175,7 +227,7 @@ export default class ArithmeticSteps {
 
 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.
 
-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)
+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.7.0/docs/transpiling.md)
 
 ## Transpilers and TypeScript
 
@@ -198,35 +250,35 @@ There are two different bundlers, or transpilers, used in cucumber-tsflow: **ts-
 The following 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: false,
-		resolveJsonModule: true,
-		skipLibCheck: true,
-		lib: ['es2022', 'esnext.decorators']
-	}
-```
-
-This next typescript configuration is used in the ts-node transpilers configured for official decorators:
+ compilerOptions: {
+  module: 'nodeNext',
+  target: 'es2022',
+  strict: 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 experimental decorators:
 
 ```typescript
-	compilerOptions: {
-		module: 'nodeNext',
-		target: 'es2022',
-		strict: true,
-		allowJs: true,
-		allowSyntheticDefaultImports: true,
-		esModuleInterop: true,
-		experimentalDecorators: true,
-		resolveJsonModule: true,
-		skipLibCheck: true,
-		lib: ['es2022']
-	}
+ 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.
@@ -236,19 +288,19 @@ When test runs are started, the settings from your local tsconfig.json are loade
 For example, the settings from the cucumber-tsflow vue test project is shown below:
 
 ```json
-	"compilerOptions": {
-		"baseUrl": ".",
-		"module": "nodeNext",
-		"target": "es2022",
-		"strict": true,
-		"allowJs": true,
-		"allowSyntheticDefaultImports": true,
-		"esModuleInterop": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"lib": ["es2022", "esnext.decorators"],
-		"typeRoots": ["../../node_modules/@types"]
-	}
+ "compilerOptions": {
+  "baseUrl": ".",
+  "module": "nodeNext",
+  "target": "es2022",
+  "strict": true,
+  "allowJs": true,
+  "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.
@@ -263,11 +315,11 @@ Cucumber-tsflow provides two esbuild transpilers: one with esbuild and support f
 
 ```typescript
 const commonOptions: CommonOptions = {
-	format: 'cjs',
-	logLevel: 'info',
-	target: [`es2022`],
-	minify: false,
-	sourcemap: 'external'
+ format: 'cjs',
+ logLevel: 'info',
+ target: [`es2022`],
+ minify: false,
+ sourcemap: 'external'
 };
 ```
 
@@ -281,10 +333,10 @@ When using official decorators the following settings are added using the esbuil
 
 ```typescript
 commonOptions.tsconfigRaw = {
-	compilerOptions: {
-		importsNotUsedAsValues: 'remove',
-		strict: true
-	}
+ compilerOptions: {
+  importsNotUsedAsValues: 'remove',
+  strict: true
+ }
 };
 ```
 
@@ -294,11 +346,11 @@ When using experimental decorators the experimentalDecorators setting is added t
 
 ```typescript
 commonOptions.tsconfigRaw = {
-	compilerOptions: {
-		experimentalDecorators: true,
-		importsNotUsedAsValues: 'remove',
-		strict: true
-	}
+ compilerOptions: {
+  experimentalDecorators: true,
+  importsNotUsedAsValues: 'remove',
+  strict: true
+ }
 };
 ```
 
@@ -338,7 +390,7 @@ You can also add a script to package.json to execute the tests as shown below:
 
 ```json
 "scripts": {
-	"test": "cucumber-tsflow -p esnode"
+ "test": "cucumber-tsflow -p esnode"
 }
 ```
 
@@ -396,20 +448,21 @@ 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/v12.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.7.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: 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`             | `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   |
+| `parallelLoad`           | `boolean \| number` | No         |                             | Pre-warm transpiler caches in parallel worker threads before loading support code. `true` = auto thread count, number = explicit count. | 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/v12.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.7.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.
 
@@ -437,27 +490,27 @@ In the table above:
 
 **NOTE:** When using Vue transpilers **jsdom** is also loaded globally to support loading and testing Vue SFC components.
 
-##### Using the transpiler configuration option
+#### Using the transpiler configuration option
 
 When configuring cucumber to execute tests you can specify which transpiler to use with the `transpiler` configuration option as shown below:
 
 ```json
 {
-	"default": {
-		"transpiler": "es-vue"
-	}
+ "default": {
+  "transpiler": "es-vue"
+ }
 }
 ```
 
-##### Alternate without using the transpiler option
+#### Alternate without using the transpiler option
 
 You can also use the `requireModule` parameter to configure a transpiler. The following example shows how to configure cucumber to use the `esvue` transpiler with the `requireModule` option.
 
 ```json
 {
-	"default": {
-		"requireModule": ["@lynxwall/cucumber-tsflow/esvue"]
-	}
+ "default": {
+  "requireModule": ["@lynxwall/cucumber-tsflow/esvue"]
+ }
 }
 ```
 
@@ -467,45 +520,45 @@ The new `debugFile` configuration option allows you to specify a .ts file with s
 
 If using VSCode to edit your project the following launch configurations can be used:
 
-##### Debug All
+#### Debug All
 
 ```json
 {
-	"name": "Debug All",
-	"type": "node",
-	"request": "launch",
-	"program": "${workspaceRoot}/node_modules/@lynxwall/cucumber-tsflow/bin/cucumber-tsflow/vue",
-	"stopOnEntry": true,
-	"args": ["-p", "esvue"],
-	"cwd": "${workspaceRoot}",
-	"runtimeExecutable": null,
-	"runtimeArgs": ["--nolazy"],
-	"env": {
-		"NODE_ENV": "development"
-	},
-	"console": "integratedTerminal",
-	"sourceMaps": true
+ "name": "Debug All",
+ "type": "node",
+ "request": "launch",
+ "program": "${workspaceRoot}/node_modules/@lynxwall/cucumber-tsflow/bin/cucumber-tsflow/vue",
+ "stopOnEntry": true,
+ "args": ["-p", "esvue"],
+ "cwd": "${workspaceRoot}",
+ "runtimeExecutable": null,
+ "runtimeArgs": ["--nolazy"],
+ "env": {
+  "NODE_ENV": "development"
+ },
+ "console": "integratedTerminal",
+ "sourceMaps": true
 }
 ```
 
-##### Debug Feature
+#### Debug Feature
 
 ```json
 {
-	"name": "Debug Feature",
-	"type": "node",
-	"request": "launch",
-	"program": "${workspaceRoot}/node_modules/@lynxwall/cucumber-tsflow/bin/cucumber-tsflow/vue",
-	"stopOnEntry": true,
-	"args": ["--debug-file", "${file}", "-p", "esvue"],
-	"cwd": "${workspaceRoot}",
-	"runtimeExecutable": null,
-	"runtimeArgs": ["--nolazy"],
-	"env": {
-		"NODE_ENV": "development"
-	},
-	"console": "integratedTerminal",
-	"sourceMaps": true
+ "name": "Debug Feature",
+ "type": "node",
+ "request": "launch",
+ "program": "${workspaceRoot}/node_modules/@lynxwall/cucumber-tsflow/bin/cucumber-tsflow/vue",
+ "stopOnEntry": true,
+ "args": ["--debug-file", "${file}", "-p", "esvue"],
+ "cwd": "${workspaceRoot}",
+ "runtimeExecutable": null,
+ "runtimeArgs": ["--nolazy"],
+ "env": {
+  "NODE_ENV": "development"
+ },
+ "console": "integratedTerminal",
+ "sourceMaps": true
 }
 ```
 
@@ -558,9 +611,9 @@ The following Scenario uses boolean values in the Given and Then statements:
 
 ```gherkin
 Scenario: Boolean type supported
-	Given I pass true into a step
-	When checking the boolean value
-	Then we can see that true was passed in
+ Given I pass true into a step
+ When checking the boolean value
+ Then we can see that true was passed in
 ```
 
 The associated step definition replaces `true` in this scenario with a `{boolean}` expression as shown below:
@@ -568,17 +621,17 @@ The associated step definition replaces `true` in this scenario with a `{boolean
 ```typescript
 @given('I pass {boolean} into a step')
 iPassbooleanIntoAStep(boolean: boolean): any {
-	this.boolValue = boolean;
+ this.boolValue = boolean;
 }
 
 @when('checking the boolean value')
 checkingTheBooleanValue(): any {
-	expect(this.boolValue).not.to.be.undefined;
+ expect(this.boolValue).not.to.be.undefined;
 }
 
 @then('we can see that {boolean} was passed in')
 weCanThatbooleanWasPassedIn(boolean: boolean): any {
-	expect(this.boolValue).to.equal(boolean);
+ expect(this.boolValue).to.equal(boolean);
 }
 ```
 
@@ -606,7 +659,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/v12.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.7.0/docs/support_files/hooks.md>
 
 ## Hooks
 
@@ -638,12 +691,12 @@ class MySteps {
 
     @beforeStep('@addNumbers')
     public beforeStep() {
-	    ...
+     ...
     }
 
     @afterStep('@addNumbers')
     public afterStep() {
-	    ...
+     ...
     }
 
     @after()
@@ -707,15 +760,15 @@ If it doesn't already exist, create a file named cucumber.json at the root of yo
 
 #### 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/v12.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.7.0/docs/custom_snippet_syntaxes.md>
 
 ```typescript
 {
-	"default": {
-		"format": [
-			"behave:cucumber_report.json"
-		]
-	}
+ "default": {
+  "format": [
+   "behave:cucumber_report.json"
+  ]
+ }
 }
 ```
 
@@ -725,11 +778,11 @@ The following example shows how to configure the bamboo junit formatter in cucum
 
 ```typescript
 {
-	"default": {
-		"format": [
-			"junitbamboo:cucumber_report.xml"
-		]
-	}
+ "default": {
+  "format": [
+   "junitbamboo:cucumber_report.xml"
+  ]
+ }
 }
 ```
 
@@ -756,7 +809,7 @@ Each scenario in a feature will get a new instance of the _Context_ object when
   - Context classes now support an `initialize()` function that can be defined synchronous or asynchronous. The `initialize()` function is called after the `BeforeAll` hook and before any other hooks or steps. This provides the ability to initialize a scenario context before any tests are executed with support for async operations.
   - Context classes have always supported a `dispose()` function for cleanup. However, with latest updates the `dispose()` function can be defined synchronously or asynchronously.
 - versions >= 6.4.0
-  - The current Cucumber World object is now available as a constructor parameter on all classes defined for Context Injection. For more information on the World object see: [Access to Cucumber.js World object](#access-to-cucumber.js-world-object).
+  - The current Cucumber World object is now available as a constructor parameter on all classes defined for Context Injection. For more information on the World object see: [Access to Cucumber.js World object](#access-to-cucumberjs-world-object).
 
 ### Using Context Injection
 
@@ -773,30 +826,30 @@ import { World } from '@cucumber/cucumber';
 import { EndTestCaseInfo, StartTestCaseInfo } from '@lynxwall/cucumber-tsflow';
 
 export class ScenarioContext {
-	public world: World;
-	public someValue = '';
-	private id: string = '';
-
-	constructor(worldObj: World) {
-		this.world = worldObj;
-	}
-	public initialize({ pickle, gherkinDocument }: StartTestCaseInfo): void {
-		this.id = this.makeid(5);
-		console.log(`Sync init: ${this.id}`);
-		console.log(`Start Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
-	}
-	public dispose({ pickle, gherkinDocument }: EndTestCaseInfo): void {
-		console.log(`Sync dispose: ${this.id}`);
-		console.log(`End Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
-	}
-	private getFeatureAndScenario(path: string, scenario: string): string | undefined {
-		...
+ public world: World;
+ public someValue = '';
+ private id: string = '';
+
+ constructor(worldObj: World) {
+  this.world = worldObj;
+ }
+ public initialize({ pickle, gherkinDocument }: StartTestCaseInfo): void {
+  this.id = this.makeid(5);
+  console.log(`Sync init: ${this.id}`);
+  console.log(`Start Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
+ }
+ public dispose({ pickle, gherkinDocument }: EndTestCaseInfo): void {
+  console.log(`Sync dispose: ${this.id}`);
+  console.log(`End Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
+ }
+ private getFeatureAndScenario(path: string, scenario: string): string | undefined {
+  ...
         return `${fileName}: ${scenario.split(' ').join('-')}`;
-	}
-	private makeid(length: number) {
-		...
-		return result;
-	}
+ }
+ private makeid(length: number) {
+  ...
+  return result;
+ }
 }
 ```
 
@@ -807,39 +860,39 @@ import { World } from '@cucumber/cucumber';
 import { EndTestCaseInfo, StartTestCaseInfo } from '@lynxwall/cucumber-tsflow';
 
 export class ScenarioContext {
-	public world: World;
-	public someValue = '';
-	private id: string = '';
-
-	constructor(worldObj: World) {
-		this.world = worldObj;
-	}
-	public async initialize({ pickle, gherkinDocument }: StartTestCaseInfo): Promise<void> {
-		this.id = this.makeid(5);
-		await this.logTest(`Async init: ${this.id}`);
-		await this.logTest(`Start Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
-	}
-	public async dispose({ pickle, gherkinDocument }: EndTestCaseInfo): Promise<void> {
-		await this.logTest(`Async dispose: ${this.id}`);
-		await this.logTest(`End Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
-	}
-	async logTest(text: string): Promise<void> {
-		await Promise.resolve(console.log(text));
-	}
-	private getFeatureAndScenario(path: string, scenario: string): string | undefined {
-		...
+ public world: World;
+ public someValue = '';
+ private id: string = '';
+
+ constructor(worldObj: World) {
+  this.world = worldObj;
+ }
+ public async initialize({ pickle, gherkinDocument }: StartTestCaseInfo): Promise<void> {
+  this.id = this.makeid(5);
+  await this.logTest(`Async init: ${this.id}`);
+  await this.logTest(`Start Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
+ }
+ public async dispose({ pickle, gherkinDocument }: EndTestCaseInfo): Promise<void> {
+  await this.logTest(`Async dispose: ${this.id}`);
+  await this.logTest(`End Test Case: ${this.getFeatureAndScenario(gherkinDocument.uri!, pickle.name)}`);
+ }
+ async logTest(text: string): Promise<void> {
+  await Promise.resolve(console.log(text));
+ }
+ private getFeatureAndScenario(path: string, scenario: string): string | undefined {
+  ...
         return `${fileName}: ${scenario.split(' ').join('-')}`;
-	}
+ }
     private makeid(length: number) {
-		...
-		return result;
-	}
+  ...
+  return result;
+ }
 }
 ```
 
 **Initialize Binding in Step class:**
 
-- Update the `@binding()` decorator to indicate the types of context objects that are required by the 'binding' class. You can include up to nine separate _Context_ objects.
+- Update the `@binding()` decorator to indicate the types of context objects that are required by the 'binding' class. There is no limit on the number of _Context_ objects.
 - Define a constructor on the `@binding` class with steps that need access to the shared data that accepts one or more context objects as parameters based on initialization of the `@binding` decorator.
 
 **Single Context class example:**
@@ -851,18 +904,18 @@ import { expect } from 'chai';
 
 @binding([ScenarioContext])
 export default class InjectionTestSteps1 {
-	constructor(private context: ScenarioContext) {}
-
-	@given('The Workspace is available and valid')
-	theWorkspaceIsAvailableAndValid() {
-		expect(this.context).not.to.be.undefined;
-		expect(this.context.world).not.to.be.undefined;
-	}
-
-	@when('I change the workspace in one step definition class')
-	whenIChangeTheWorkspaceInOneStep() {
-		this.context.someValue = 'value changed';
-	}
+ constructor(private context: ScenarioContext) {}
+
+ @given('The Workspace is available and valid')
+ theWorkspaceIsAvailableAndValid() {
+  expect(this.context).not.to.be.undefined;
+  expect(this.context.world).not.to.be.undefined;
+ }
+
+ @when('I change the workspace in one step definition class')
+ whenIChangeTheWorkspaceInOneStep() {
+  this.context.someValue = 'value changed';
+ }
 }
 ```
 
@@ -876,24 +929,24 @@ import { expect } from 'chai';
 
 @binding([ScenarioContext, SyncContext])
 export default class InjectionTestSteps1 {
-	constructor(
-		private context: ScenarioContext,
-		private syncContext: SyncContext
-	) {}
-
-	@given('The Workspace is available and valid')
-	theWorkspaceIsAvailableAndValid() {
-		expect(this.context).not.to.be.undefined;
-		expect(this.context.world).not.to.be.undefined;
-
-		expect(this.syncContext).not.to.be.undefined;
-		expect(this.syncContext.world).not.to.be.undefined;
-	}
-
-	@when('I change the workspace in one step definition class')
-	whenIChangeTheWorkspaceInOneStep() {
-		this.context.someValue = 'value changed';
-	}
+ constructor(
+  private context: ScenarioContext,
+  private syncContext: SyncContext
+ ) {}
+
+ @given('The Workspace is available and valid')
+ theWorkspaceIsAvailableAndValid() {
+  expect(this.context).not.to.be.undefined;
+  expect(this.context.world).not.to.be.undefined;
+
+  expect(this.syncContext).not.to.be.undefined;
+  expect(this.syncContext.world).not.to.be.undefined;
+ }
+
+ @when('I change the workspace in one step definition class')
+ whenIChangeTheWorkspaceInOneStep() {
+  this.context.someValue = 'value changed';
+ }
 }
 ```
 
@@ -911,16 +964,16 @@ Starting with version **6.4.0** the Cucumber World object is now passed into a _
 import { World } from '@cucumber/cucumber';
 
 export class ScenarioContext {
-	public world: World;
-	public someValue = '';
+ public world: World;
+ public someValue = '';
 
-	constructor(worldObj: World) {
-		this.world = worldObj;
-	}
+ constructor(worldObj: World) {
+  this.world = worldObj;
+ }
 
-	public dispose(): void {
-		this.someValue = '';
-	}
+ public dispose(): void {
+  this.someValue = '';
+ }
 }
 ```
 
@@ -942,8 +995,8 @@ With this approach, you would define a world property on simple _Context_ class
 import { World } from '@cucumber/cucumber';
 
 export class ScenarioContext {
-	public world!: World;
-	public someValue = '';
+ public world!: World;
+ public someValue = '';
 }
 ```
 
@@ -958,14 +1011,14 @@ import { World } from '@cucumber/cucumber';
 
 @binding([ScenarioContext])
 export default class WorldContext {
-	_worldObj?: World;
+ _worldObj?: World;
 
-	constructor(private context: ScenarioContext) {}
+ constructor(private context: ScenarioContext) {}
 
-	@before()
-	beforeScenario() {
-		this.context.world = this._worldObj as World;
-	}
+ @before()
+ beforeScenario() {
+  this.context.world = this._worldObj as World;
+ }
 }
 ```