[
{
"path": ".build/setPackageVersion.js",
"content": "const nbgv = require(\"nerdbank-gitversioning\");\n\nconst setPackageVersionAndBuildNumber = (versionInfo) => {\n // Set a build output value representing the NPM package version\n console.log(\n \"::set-output name=package_version::\" + versionInfo.npmPackageVersion,\n );\n\n nbgv.setPackageVersion(\"cucumber-tsflow\");\n nbgv.setPackageVersion(\"cucumber-tsflow-specs\");\n};\n\nconst handleError = (err) =>\n console.error(\n \"Failed to update the package version number. nerdbank-gitversion failed: \" +\n err,\n );\n\nnbgv.getVersion().then(setPackageVersionAndBuildNumber).catch(handleError);\n"
},
{
"path": ".github/workflows/ci.yml",
"content": "name: CI\non:\n push:\n branches: [master, release/**]\n pull_request:\n branches: [master, release/**]\njobs:\n # Build and Test the 'cucumber-tsflow' package\n build:\n name: Build and Test\n runs-on: ubuntu-latest\n strategy:\n matrix:\n cucumberVersion: [\"^10\", \"^11\", \"^12\"]\n steps:\n - uses: actions/checkout@v4\n - uses: actions/setup-node@v4\n with:\n node-version: 22\n - name: Install npm packages\n run: |-\n npm ci\n npm install @cucumber/cucumber@${{ matrix.cucumberVersion }}\n - name: Build\n run: npm run build\n - name: Run specification tests\n run: npm test\n"
},
{
"path": ".github/workflows/release.yml",
"content": "#\n# This workflow creates a release from a specified branch. The Package version is managed\n# by Nerdbank Gitversioning based on configuration held in 'version.json' file.\n#\nname: Release\non:\n workflow_dispatch:\n\njobs:\n # Build, Test and Pack the 'cucumber-tsflow' package\n build:\n name: Build and Test\n runs-on: ubuntu-latest\n outputs:\n version: ${{ steps.set_package_version.outputs.NpmPackageVersion }}\n releaseTag: ${{ steps.tagInfo.outputs.releaseTag }}\n steps:\n - uses: actions/checkout@v3\n with:\n # avoid shallow clone (required by Nerbank GitVersioning)\n fetch-depth: 0\n - uses: actions/setup-node@v3\n with:\n node-version: 22\n - name: Install npm packages\n run: npm ci\n - name: Update package version\n id: set_package_version\n uses: dotnet/nbgv@master\n with:\n stamp: cucumber-tsflow/package.json\n - name: Build\n run: npm run build\n - name: Create npm package\n run: npm pack ./cucumber-tsflow\n - name: Read tag info\n id: tagInfo\n run: |-\n echo \"releaseTag=$(jq '.releaseTag // \"latest\"' version.json)\" | tee -a $GITHUB_OUTPUT\n - uses: actions/upload-artifact@v4\n with:\n name: npm-package\n path: |\n cucumber-tsflow-${{ steps.set_package_version.outputs.NpmPackageVersion }}.tgz\n\n # Publish the 'cucumber-tsflow' package to npm\n publish:\n name: Publish to npm\n runs-on: ubuntu-latest\n needs: build\n permissions:\n contents: write\n steps:\n - uses: actions/setup-node@v3\n with:\n node-version: 22\n registry-url: \"https://registry.npmjs.org\"\n - uses: actions/download-artifact@v4\n name: Download npm package\n with:\n name: npm-package\n - name: Publish npm package\n run: |-\n npm publish \\\n cucumber-tsflow-${{ needs.build.outputs.version }}.tgz \\\n --tag ${{ needs.build.outputs.releaseTag }}\n env:\n NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}\n - name: Publish GitHub release\n uses: ncipollo/release-action@v1\n with:\n tag: ${{ needs.build.outputs.version }}\n commit: ${{ github.sha }}\n artifacts: cucumber-tsflow-${{ needs.build.outputs.version }}.tgz\n generateReleaseNotes: true\n"
},
{
"path": ".github/workflows/stale.yml",
"content": "name: \"Stale issue handler\"\n\non:\n workflow_dispatch:\n schedule:\n - cron: \"0 0 * * *\"\n\npermissions:\n contents: write # only for delete-branch option\n issues: write\n pull-requests: write\n\njobs:\n stale:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/stale@v6\n id: stale\n with:\n days-before-stale: 60\n days-before-close: 7\n\n stale-issue-message: \"This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days.\"\n close-issue-message: \"There hasn't been any activity on this issue for 67 days. Closing it as Spoiled.\"\n stale-issue-label: stale\n close-issue-label: spoiled\n exempt-issue-labels: \"blocked,discussion,good first issue\"\n\n stale-pr-message: \"This PR is stale because it has been 60 days with no activity. Remove stale lable or comment or this will be closed in 7 days.\"\n close-pr-message: \"There hasn't been any activity on this PR for 67 days. Closing it as Spoiled.\"\n stale-pr-label: stale\n close-pr-label: spoiled\n exempt-pr-labels: \"blocked,discussion\"\n\n - name: Print outputs\n run: echo ${{ join(steps.stale.outputs.*, ',') }}\n"
},
{
"path": ".gitignore",
"content": "node_modules\ndist\ntmp/\n.idea/\ntsconfig.tsbuildinfo\n"
},
{
"path": ".npm-upgrade.json",
"content": "{\n \"ignore\": {\n \"@cucumber/cucumber\": {\n \"versions\": \"^8\",\n \"reason\": \"Mantain compatibility with cucumber 7 and 8\"\n }\n }\n}\n"
},
{
"path": ".run/All Tests.run.xml",
"content": "\n \n \n \n \n \n \n \n \n \n"
},
{
"path": ".run/Template Cucumber.js.run.xml",
"content": "\n \n \n \n \n \n \n \n \n \n"
},
{
"path": ".vscode/launch.json",
"content": "{\n \"version\": \"0.2.0\",\n \"configurations\": [\n {\n \"name\": \"Specs\",\n \"type\": \"node\",\n \"request\": \"launch\",\n \"program\": \"${workspaceRoot}/node_modules/cucumber/bin/cucumber-js\",\n \"stopOnEntry\": true,\n \"args\": [\"--require\", \"./cucumber-tsflow-specs/dist\"],\n \"cwd\": \"${workspaceRoot}\",\n \"runtimeExecutable\": null,\n \"runtimeArgs\": [\"--nolazy\"],\n \"env\": {\n \"NODE_ENV\": \"development\"\n },\n \"externalConsole\": false,\n \"sourceMaps\": true,\n \"outDir\": null\n },\n {\n \"name\": \"Attach\",\n \"type\": \"node\",\n \"request\": \"attach\",\n \"port\": 5858,\n \"sourceMaps\": false,\n \"outDir\": null,\n \"localRoot\": \"${workspaceRoot}\",\n \"remoteRoot\": null\n }\n ]\n}\n"
},
{
"path": ".vscode/settings.json",
"content": "{\n \"typescript.tsdk\": \"node_modules\\\\typescript\\\\lib\"\n}\n"
},
{
"path": "CONTRIBUTE.md",
"content": "The project should set-up all of its inner links and bindings when you first install it.\n\nRun the tests locally to ensure everything is properly configured.\n\n```terminal\n> git clone https://github.com/timjroberts/cucumber-js-tsflow.git\n> cd cucumber-js-tsflow\n> npm install\n> npm test\n```\n\n## Setting up Run/Debug in IDE\n\nFor IntelliJ, a run configuration is stored in `.run/cucumber-js.run.xml` to run/debug the tests.\n\nFor other IDE, using the following runtime config for node:\n\n- working dir: `cucumber-tsflow-spec`\n- node-parameters: `--require ts-node/register `\n- js script to run: `node_modules/@cucumber/cucumber/bin/cucumber-js`\n- application parameters: `features/**/*.feature --require \"src/step_definitions/**/*.ts\" `\n\nAn example command line runner:\n\n```shell script\n\"C:\\Program Files\\nodejs\\node.exe\" --require ts-node/register C:\\Users\\wudon\\repo\\cucumber-js-tsflow\\node_modules\\@cucumber\\cucumber\\bin\\cucumber-js features/**/*.feature --require src/step_definitions/**/*.ts\n```\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2018-2020 Tim Roberts and contributors.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "# cucumber-tsflow\n\n\n\nProvides 'SpecFlow' like bindings for CucumberJS in TypeScript 1.7+.\n\n## Table of content\n\nSee that menu icon to the left of \"README.md\"?\n\nDid you know that every markdown file in GitHub with more than two headings\nhave that icon as a Table of Content linking to every heading?\n\n## Quick Start\n\ncucumber-tsflow uses TypeScript Decorators to create SpecFlow like bindings for\nTypeScript classes and methods that allow those classes and methods to be used\nin your CucumberJS support files. As such, cucumber-tsflow has a peer dependency\non CucumberJS, and you still run your specifications using the cucumber\ncommand line tool.\n\n### Install cucumber and cucumber-tsflow\n\n```bash\nnpm install @cucumber/cucumber cucumber-tsflow\n```\n\n### Create .feature files to describe your specifications\n\nBy default, CucumberJS looks for .feature files in a folder called 'features',\nso create that folder and then create a new file called `my_feature.feature`:\n\n```gherkin\n# features/my_feature.feature\n\nFeature: Example Feature\n This is an example feature\n\n Scenario: Adding two numbers\n Given I enter '2' and '8'\n Then I receive the result '10'\n```\n\n### Create the Support Files to support the Feature\n\nCucumberJS requires Support Files defining what each step in the Feature files mean.\n\nBy default, CucumberJS looks for Support Files beneath the 'features' folder.\nWe need to write step definitions to support the two steps that we created above.\n\nCreate a new `ArithmeticSteps.ts` file:\n\n```ts\n// features/ArithmeticSteps.ts\n\nimport { binding, given, then } from \"cucumber-tsflow\";\n\n@binding()\nclass ArithmeticSteps {\n private computedResult: number;\n\n @given(/I enter '(\\d*)' and '(\\d*)'/)\n public givenTwoNumbers(num1: string, num2: string): void {\n this.computedResult = parseInt(num1) + parseInt(num2);\n }\n\n @then(/I receive the result '(\\d*)'/)\n public thenResultReceived(expectedResult: string): void {\n if (parseInt(expectedResult) !== this.computedResult) {\n throw new Error(\"Arithmetic Error\");\n }\n }\n}\n\nexport = ArithmeticSteps;\n```\n\nNote how the cucumber-tsflow Decorators are being used to bind the methods in\nthe class. During runtime, these Decorators simply call the Cucumber code on\nyour behalf in order to register callbacks with Given(), When(), Then(), etc.\n\nThe callbacks that are being registered with Cucumber are wrappers around your\nbound class. This allows you to maintain a state between each step on the same\nclass by using instance properties.\n\nIn this quick example, the entire test state is encapsulated directly in the class.\nAs your test suite grows larger and step definitions get shared between\nmultiple classes, you can use 'Context Injection' to share state between\nrunning step definitions (see below).\n\n### Compiling your TypeScript Support Code\n\nTo use `cucumber-tsflow` with TypeScript, you'll also need a `tsconfig.json` file\nwith these options:\n\n```json\n{\n \"compilerOptions\": {\n \"moduleResolution\": \"node\",\n \"experimentalDecorators\": true\n }\n}\n```\n\n> Hint: You can add that to `features/tsconfig.json` to have it applied only for\n> your integration tests.\n\nWith the TS config in place, CucumberJS should automatically compile your code\nbefore running it.\n\n## Reference\n\n### Bindings\n\nBindings provide the automation that connects a specification step in a Gherkin\nfeature file to some code that executes for that step.\nWhen using Cucumber with TypeScript you can define this automation using the\n`binding` decorator on top of a class:\n\n```ts\nimport { binding } from \"cucumber-tsflow\";\n\n@binding()\nclass MySteps {\n // ...\n}\n\nexport = MySteps;\n```\n\nThrough this reference, classes decorated with the `binding` decorator are\nreferred \"binding classes\".\n\n_Note_: You must use the `export = ;` due to how Cucumber interprets\nthe exported items of a Support File.\n\n### Step Definitions\n\nStep definitions can be bound to automation code in a binding class by decorating\na public function with a 'given', 'when' or 'then' binding decorator:\n\n```ts\nimport { binding, given, when, then } from \"cucumber-tsflow\";\n\n@binding()\nclass MySteps {\n @given(/I perform a search using the value \"([^\"]*)\"/)\n public givenAValueBasedSearch(searchValue: string): void {\n // ...\n }\n}\n\nexport = MySteps;\n```\n\nThe methods have the same requirements and guarantees of functions you would normally\nsupply to Cucumber, which means that the methods may be:\n\n- Synchronous by returning `void`\n- Asynchronous by receiving and using a callback as the last parameter\\\n The callback has signature `() => void`\n- Asynchronous by returning a `Promise`\n\nThe step definition functions must always receive a pattern as the first argument,\nwhich can be either a string or a regular expression.\n\nAdditionally, a step definition may receive additional options in the format:\n\n```ts\n@binding()\nclass MySteps {\n @given(\"pattern\", {\n tag: \"not @expensive\",\n timeout: 1000,\n wrapperOptions: {},\n })\n public givenAValueBasedSearch(searchValue: string): void {\n // ...\n }\n}\n```\n\nFor backward compatibility, the `tag` and `timeout` options can also be passed\nas direct arguments:\n\n```ts\n@binding()\nclass MySteps {\n @given(\"pattern\", \"not @expensive\", 1000)\n public givenAValueBasedSearch(searchValue: string): void {\n // ...\n }\n}\n```\n\n### Hooks\n\nHooks can be used to add logic that happens before or after each scenario execution.\nThey are configured in the same way as the [Step Definitions](#step-definitions).\n\n```typescript\nimport { binding, before, beforeAll, after, afterAll } from \"cucumber-tsflow\";\n\n@binding()\nclass MySteps {\n @beforeAll()\n public static beforeAllScenarios(): void {\n // ...\n }\n\n @afterAll()\n public static beforeAllScenarios(): void {\n // ...\n }\n\n @before()\n public beforeAllScenarios(): void {\n // ...\n }\n\n @after()\n public afterAllScenarios(): void {\n // ...\n }\n}\n\nexport = MySteps;\n```\n\nContrary to the Step Definitions, Hooks don't need a pattern since they don't\nrun for some particular step, but once for each scenario.\n\nHooks can receive aditional options just like the Step Definitions:\n\n```ts\n@binding()\nclass MySteps {\n // Runs before each scenarios with tag `@requireTempDir` with 2 seconds of timeout\n @before({ tag: \"@requireTempDir\", timeout: 2000 })\n public async beforeAllScenariosRequiringTempDirectory(): Promise {\n let tempDirInfo = await this.createTemporaryDirectory();\n // ...\n }\n\n // Runs after each scenarios with tag `@requireTempDir` with 2 seconds of timeout\n @after({ tag: \"@requireTempDir\", timeout: 2000 })\n public async afterAllScenariosRequiringTempDirectory(): void {\n await this.deleteTemporaryDirectory();\n // ...\n }\n}\n```\n\nFor backward compatibility, the `tag` option can also be passes as a direct argument:\n\n```ts\n@binding()\nclass MySteps {\n @before('@local')\n public async runForLocalOnly(): Promise {\n ...\n }\n}\n```\n\n### Step and hook options\n\n#### Tag filters\n\nBoth Step Definitions and Hooks can receive a `tag` option. This option defines\na filter such that the binding will only be considered for scenarios matching\nthe filter.\n\nThe syntax of the tag filter is\na [\"Tag expression\"](https://cucumber.io/docs/cucumber/api/?lang=javascript#tag-expressions)\nspecified by Cucumber.\n\n**Note**: The tag might be set for the `Feature` or for the `Scenario`, and there\nis no distinction between them. This is\ncalled [\"Tag Inheritance\"](https://cucumber.io/docs/cucumber/api/?lang=javascript#tag-inheritance).\n\nFor backward compatibility, setting a tag to a single word is treated the same\nas a filter for that word as a tag:\n\n```ts\n// This backward compatible format\n@given({ tag: 'foo' })\n\n// Is transformed into this\n@given({ tag: '@foo' })\n```\n\n#### Timeout\n\nBoth Step Definition and Hooks can receive a `timeout` option. This option defines\nthe maximum runtime allowed for the binding before it is flagged as failed.\n\n`cucumber-tsflow` currently doesn't have a way to define a global default step timeout,\nbut it can be easily done through CucumberJS' `setDefaultTimeout` function.\n\n#### Passing WrapOptions\n\nIn step definition, we can passing additional wrapper options to CucumberJS.\n\nFor example:\n\n```typescript\n@given(/I perform a search using the value \"([^\"]*)\"/, { wrapperOptions: { retry: 2 } })\npublic\ngivenAValueBasedSearch(searchValue\n:\nstring\n):\nvoid {\n ...\n}\n```\n\nThe type of `wrapperOptions` is defined by the function given to `setDefinitionFunctionWrapper`.\n\n**Note**: `wrapperOptions` and `setDefinitionFunctionWrapper` were deprecated in\n[CucumberJS 7.3.1](https://github.com/cucumber/cucumber-js/blob/8900158748a3f36c4b2fa5d172fe27013b39ab17/CHANGELOG.md#731---2021-07-20)\nand are kept here for backward compatibility only while this library supports\nCucumberJS 7.\n\n### Sharing Data between Bindings\n\n#### Context Injection\n\nLike 'SpecFlow', `cucumber-tsflow` supports a simple dependency injection\nframework that will instantitate and inject class instances into binding classes\nfor each executing scenario.\n\nTo use context injection:\n\n- Create simple classes representing the shared data and/or behavior.\\\n These classes **must** have public constructors with no arguments (default constructors).\n Defining a class with no constructor at all also works.\n- Define a constructor on the binding classes that receives an instance of\n the class defined above as an parameter.\n- Update the `@binding()` decorator to indicate the types of context objects\n that are required by the binding class\n\n```ts\n// Workspace.ts\n\nexport class Workspace {\n public folder: string = \"default folder\";\n\n public updateFolder(folder: string) {\n this.folder = folder;\n }\n}\n\n// my-steps.ts\nimport { binding, before, after } from \"cucumber-tsflow\";\nimport { Workspace } from \"./Workspace\";\n\n@binding([Workspace])\nclass MySteps {\n public constructor(protected workspace: Workspace) {}\n\n @before(\"requireTempDir\")\n public async beforeAllScenariosRequiringTempDirectory(): Promise {\n let tempDirInfo = await this.createTemporaryDirectory();\n\n this.workspace.updateFolder(tempDirInfo);\n }\n}\n\nexport = MySteps;\n```\n\n#### Provided Context Types\n\nThis library provides 3 Context Types to interact with CucumberJS' World object.\n\n- `WorldParameters`, which expose value passed to the `worldParameters` configuration\n or the `--world-parameters` CLI option.\n- `CucumberLog`, which exposes the `log` method of the `World` object.\n- `CucumberAttachments`, which exposes the `attach` method of the `World` object.\n- `ScenarioInfo`, which exposes information about the running scenario and allows\n changing the behavior of steps and hooks based on tags easier.\n"
},
{
"path": "cucumber-tsflow/.npmignore",
"content": "*.ts\ntsconfig.json\ntypings.json\ntypings\n.npmignore\n*.tsbuildinfo\n!dist/**/*.d.ts\n"
},
{
"path": "cucumber-tsflow/package.json",
"content": "{\n \"name\": \"cucumber-tsflow\",\n \"description\": \"Provides 'specflow' like bindings for CucumberJS 7.0.0+ in TypeScript 1.7+.\",\n \"version\": \"5.0.0\",\n \"author\": \"Tim Roberts \",\n \"maintainers\": [\n {\n \"name\": \"Luiz Ferraz\",\n \"email\": \"luiz@lferraz.com\",\n \"url\": \"https://github.com/Fryuni\"\n }\n ],\n \"license\": \"MIT\",\n \"main\": \"./dist\",\n \"keywords\": [\n \"testing\",\n \"bdd\",\n \"cucumber\",\n \"gherkin\",\n \"tests\",\n \"typescript\",\n \"specflow\"\n ],\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"https://github.com/timjroberts/cucumber-js-tsflow.git\"\n },\n \"dependencies\": {\n \"log4js\": \"^6.9.1\",\n \"source-map-support\": \"^0.5.21\",\n \"underscore\": \"^1.13.8\"\n },\n \"peerDependencies\": {\n \"@cucumber/cucumber\": \"^10 || ^11 || ^12\"\n }\n}\n"
},
{
"path": "cucumber-tsflow/src/binding-decorator.ts",
"content": "import {\n After,\n AfterAll,\n AfterStep,\n Before,\n BeforeAll,\n BeforeStep,\n Given,\n Then,\n When,\n World,\n} from \"@cucumber/cucumber\";\nimport {\n IDefineStepOptions,\n IDefineTestStepHookOptions,\n} from \"@cucumber/cucumber/lib/support_code_library_builder/types\";\nimport { PickleTag } from \"@cucumber/messages\";\nimport * as _ from \"underscore\";\nimport { BindingRegistry, DEFAULT_TAG } from \"./binding-registry\";\nimport logger from \"./logger\";\nimport {\n ManagedScenarioContext,\n ScenarioContext,\n ScenarioInfo,\n} from \"./managed-scenario-context\";\nimport {\n CucumberAttachments,\n CucumberLog,\n WorldParameters,\n} from \"./provided-context\";\nimport { StepBinding, StepBindingFlags } from \"./step-binding\";\nimport { ContextType, StepPattern, TypeDecorator } from \"./types\";\n\ninterface WritableWorld extends World {\n [key: string]: any;\n}\n\n/**\n * The property name of the current scenario context that will be attached to the Cucumber\n * world object.\n */\nconst SCENARIO_CONTEXT_SLOTNAME: string = \"__SCENARIO_CONTEXT\";\n\n/**\n * A set of step patterns that have been registered with Cucumber.\n *\n * In order to support scoped (or tagged) step definitions, we must ensure that any step binding is\n * only registered with Cucumber once. The binding function for that step pattern then becomes\n * responsible for looking up and execuing the step binding based on the context that is in scope at\n * the point of invocation.\n */\nconst stepPatternRegistrations = new Map();\n\n// tslint:disable:no-bitwise\n\nfunction ensureNoCyclicDependencies(target: any, currentPath: any[] = []) {\n const dependencies = BindingRegistry.instance.getContextTypesForTarget(\n target.prototype,\n );\n\n if (dependencies.length === 0) {\n return;\n }\n\n for (const dependency of dependencies) {\n if (dependency === undefined) {\n throw new Error(\n `Undefined dependency detected in ${target.name}. You possibly have an import cycle.\\n` +\n \"See https://nodejs.org/api/modules.html#modules_cycles\",\n );\n }\n\n if (currentPath.includes(dependency)) {\n throw new Error(\n `Cyclic dependency detected: ${dependency.name} -> ${target.name} -> ${currentPath.map((t) => t.name).join(\" -> \")}`,\n );\n }\n\n ensureNoCyclicDependencies(dependency, [...currentPath, target]);\n }\n}\n\n/**\n * A class decorator that marks the associated class as a CucumberJS binding.\n *\n * @param requiredContextTypes An optional array of Types that will be created and passed into the created\n * object for each scenario.\n *\n * An instance of the decorated class will be created for each scenario.\n */\nexport function binding(requiredContextTypes?: ContextType[]): TypeDecorator {\n return (target: new (...args: any[]) => T) => {\n ensureSystemBindings();\n const bindingRegistry = BindingRegistry.instance;\n bindingRegistry.registerContextTypesForTarget(\n target.prototype,\n requiredContextTypes,\n );\n\n ensureNoCyclicDependencies(target);\n\n const allBindings: StepBinding[] = [\n ...bindingRegistry.getStepBindingsForTarget(target),\n ...bindingRegistry.getStepBindingsForTarget(target.prototype),\n ];\n\n for (const stepBinding of allBindings) {\n if (stepBinding.bindingType & StepBindingFlags.StepDefinitions) {\n let stepBindingFlags = stepPatternRegistrations.get(\n stepBinding.stepPattern.toString(),\n );\n\n if (stepBindingFlags === undefined) {\n stepBindingFlags = StepBindingFlags.none;\n }\n\n if (stepBindingFlags & stepBinding.bindingType) {\n return;\n }\n\n const bound = bindStepDefinition(stepBinding);\n\n if (bound) {\n stepPatternRegistrations.set(\n stepBinding.stepPattern.toString(),\n stepBindingFlags | stepBinding.bindingType,\n );\n }\n } else if (stepBinding.bindingType & StepBindingFlags.Hooks) {\n bindHook(stepBinding);\n } else {\n logger.trace(\"Ignored binding\", stepBinding);\n }\n }\n };\n}\n\nfunction getContextFromWorld(world: World): ScenarioContext {\n const context: unknown = (world as Record)[\n SCENARIO_CONTEXT_SLOTNAME\n ];\n\n if (context instanceof ManagedScenarioContext) {\n return context;\n }\n\n throw new Error(\n \"Scenario context have not been initialized in the provided World object.\",\n );\n}\n\nexport function getBindingFromWorld(\n world: World,\n contextType: T,\n): InstanceType {\n const context = getContextFromWorld(world);\n\n return context.getContextInstance(contextType);\n}\n\nexport function ensureWorldIsInitialized() {\n ensureSystemBindings();\n}\n\n/**\n * Ensures that the 'cucumber-tsflow' hooks are bound to Cucumber.\n *\n * @param cucumber The cucumber object.\n *\n * The hooks will only be registered with Cucumber once regardless of which binding invokes the\n * function.\n */\nconst ensureSystemBindings = _.once(() => {\n Before(function (this: WritableWorld, scenario) {\n logger.trace(\n \"Setting up scenario context for scenario:\",\n JSON.stringify(scenario),\n );\n\n const scenarioInfo = new ScenarioInfo(\n scenario.pickle.name!,\n _.map(scenario.pickle.tags!, (tag: PickleTag) => tag.name!),\n );\n\n const scenarioContext = new ManagedScenarioContext(scenarioInfo);\n\n this[SCENARIO_CONTEXT_SLOTNAME] = scenarioContext;\n\n scenarioContext.addExternalObject(scenarioInfo);\n scenarioContext.addExternalObject(new WorldParameters(this.parameters));\n scenarioContext.addExternalObject(new CucumberLog(this.log.bind(this)));\n scenarioContext.addExternalObject(\n new CucumberAttachments(this.attach.bind(this)),\n );\n });\n\n After(function (this: WritableWorld) {\n const scenarioContext = this[\n SCENARIO_CONTEXT_SLOTNAME\n ] as ManagedScenarioContext;\n\n if (scenarioContext) {\n scenarioContext.dispose();\n }\n });\n\n try {\n const stackFilter = require(\"@cucumber/cucumber/lib/filter_stack_trace\");\n const path = require(\"path\");\n\n const originalFileNameFilter = stackFilter.isFileNameInCucumber;\n\n if (originalFileNameFilter !== undefined) {\n const projectRootPath = path.join(__dirname, \"..\") + \"/\";\n\n Object.defineProperty(stackFilter, \"isFileNameInCucumber\", {\n value: (fileName: string) =>\n originalFileNameFilter(fileName) ||\n fileName.startsWith(projectRootPath) ||\n fileName.includes(\"node_modules\"),\n configurable: true,\n enumerable: true,\n });\n }\n } catch {\n // Ignore errors, proper stack filtering is not officially supported\n // so we override on a best effor basis only\n }\n\n // Decorate the Cucumber step definition snippet builder so that it uses our syntax\n\n // let currentSnippetBuilder = cucumberSys.SupportCode.StepDefinitionSnippetBuilder;\n\n // cucumberSys.SupportCode.StepDefinitionSnippetBuilder = function (step, syntax) {\n // return currentSnippetBuilder(step, {\n // build: function (functionName: string, pattern, parameters, comment) {\n // let callbackName = parameters[parameters.length - 1];\n\n // return `@${functionName.toLowerCase()}(${pattern})\\n` +\n // `public ${functionName}XXX (${parameters.join(\", \")}): void {\\n` +\n // ` // ${comment}\\n` +\n // ` ${callbackName}.pending();\\n` +\n // `}\\n`;\n // }\n // });\n // }\n});\n\n/**\n * Binds a step definition to Cucumber.\n *\n * @param stepBinding The [[StepBinding]] that represents a 'given', 'when', or 'then' step definition.\n */\nfunction bindStepDefinition(stepBinding: StepBinding): boolean {\n const bindingFunc = function (this: WritableWorld): any {\n const bindingRegistry = BindingRegistry.instance;\n\n const scenarioContext = this[\n SCENARIO_CONTEXT_SLOTNAME\n ] as ManagedScenarioContext;\n\n const matchingStepBindings = bindingRegistry.getStepBindings(\n stepBinding.stepPattern.toString(),\n );\n\n const contextTypes = bindingRegistry.getContextTypesForTarget(\n matchingStepBindings[0].targetPrototype,\n );\n const bindingObject = scenarioContext.getOrActivateBindingClass(\n matchingStepBindings[0].targetPrototype,\n contextTypes,\n );\n\n return (\n bindingObject[matchingStepBindings[0].targetPropertyKey] as () => void\n ).apply(bindingObject, arguments as any);\n };\n\n Object.defineProperty(bindingFunc, \"length\", {\n value: stepBinding.argsLength,\n });\n\n logger.trace(\"Binding step:\", stepBinding);\n\n const bindingOptions: IDefineStepOptions & IDefineTestStepHookOptions = {\n timeout: stepBinding.timeout,\n wrapperOptions: stepBinding.wrapperOption,\n tags: stepBinding.tag === DEFAULT_TAG ? undefined : stepBinding.tag,\n };\n\n if (stepBinding.bindingType & StepBindingFlags.given) {\n Given(stepBinding.stepPattern, bindingOptions, bindingFunc);\n } else if (stepBinding.bindingType & StepBindingFlags.when) {\n When(stepBinding.stepPattern, bindingOptions, bindingFunc);\n } else if (stepBinding.bindingType & StepBindingFlags.then) {\n Then(stepBinding.stepPattern, bindingOptions, bindingFunc);\n } else {\n return false;\n }\n\n return true;\n}\n\n/**\n * Binds a hook to Cucumber.\n *\n * @param cucumber The cucumber object.\n * @param stepBinding The [[StepBinding]] that represents a 'before', or 'after', step definition.\n */\nfunction bindHook(stepBinding: StepBinding): void {\n const bindingFunc = function (this: any): any {\n const scenarioContext = this[\n SCENARIO_CONTEXT_SLOTNAME\n ] as ManagedScenarioContext;\n const contextTypes = BindingRegistry.instance.getContextTypesForTarget(\n stepBinding.targetPrototype,\n );\n const bindingObject = scenarioContext.getOrActivateBindingClass(\n stepBinding.targetPrototype,\n contextTypes,\n );\n\n return (bindingObject[stepBinding.targetPropertyKey] as () => void).apply(\n bindingObject,\n arguments as any,\n );\n };\n\n const globalBindFunc = () => {\n const targetPrototype = stepBinding.targetPrototype;\n const targetPrototypeKey = stepBinding.targetPropertyKey;\n\n return targetPrototype[targetPrototypeKey].apply(targetPrototype);\n };\n\n Object.defineProperty(bindingFunc, \"length\", {\n value: stepBinding.argsLength,\n });\n\n const bindingOptions: IDefineTestStepHookOptions = {\n timeout: stepBinding.timeout,\n tags: stepBinding.tag === DEFAULT_TAG ? undefined : stepBinding.tag,\n ...(stepBinding.hookOptions ?? {}),\n };\n\n logger.trace(\"Binding hook:\", stepBinding);\n\n switch (stepBinding.bindingType) {\n case StepBindingFlags.before:\n Before(bindingOptions, bindingFunc);\n break;\n case StepBindingFlags.after:\n After(bindingOptions, bindingFunc);\n break;\n case StepBindingFlags.beforeAll:\n BeforeAll(globalBindFunc);\n break;\n case StepBindingFlags.beforeStep:\n BeforeStep(bindingFunc);\n break;\n case StepBindingFlags.afterStep:\n AfterStep(bindingFunc);\n break;\n case StepBindingFlags.afterAll:\n AfterAll(globalBindFunc);\n break;\n }\n}\n"
},
{
"path": "cucumber-tsflow/src/binding-registry.ts",
"content": "import logger from \"./logger\";\n\nimport { StepBinding } from \"./step-binding\";\nimport { ContextType, StepPattern } from \"./types\";\n\n/**\n * Describes the binding metadata that is associated with a binding class.\n */\ninterface TargetBinding {\n /**\n * A reference to the step bindings that are associated with the binding class.\n */\n stepBindings: StepBinding[];\n\n /**\n * The context types that are to be injected into the binding class during execution.\n */\n contextTypes: ContextType[];\n}\n\n/**\n * Represents the default step pattern.\n */\nexport const DEFAULT_STEP_PATTERN: string = \"/.*/\";\n\n/**\n * Represents the default tag.\n */\nexport const DEFAULT_TAG: string = \"*\";\n\n/**\n * A metadata registry that captures information about bindings and their bound step bindings.\n */\nexport class BindingRegistry {\n private _bindings = new Map();\n\n private _targetBindings = new Map();\n\n /**\n * Gets the binding registry singleton.\n *\n * @returns A [[BindingRegistry]].\n */\n public static get instance(): BindingRegistry {\n const BINDING_REGISTRY_SLOTNAME: string =\n \"__CUCUMBER_TSFLOW_BINDINGREGISTRY\";\n\n const registry = (global as any)[BINDING_REGISTRY_SLOTNAME];\n\n if (!registry) {\n (global as any)[BINDING_REGISTRY_SLOTNAME] = new BindingRegistry();\n }\n\n return registry || (global as any)[BINDING_REGISTRY_SLOTNAME];\n }\n\n /**\n * Updates the binding registry with information about the context types required by a\n * binding class.\n *\n * @param targetPrototype The class representing the binding (constructor function).\n * @param contextTypes An array of [[ContextType]] that define the types of objects that\n * should be injected into the binding class during a scenario execution.\n */\n public registerContextTypesForTarget(\n targetPrototype: any,\n contextTypes?: ContextType[],\n ): void {\n if (!contextTypes) {\n return;\n }\n\n let targetDecorations = this._targetBindings.get(targetPrototype);\n\n if (!targetDecorations) {\n targetDecorations = {\n stepBindings: [],\n contextTypes: [],\n };\n\n this._targetBindings.set(targetPrototype, targetDecorations);\n }\n\n targetDecorations.contextTypes = contextTypes;\n }\n\n /**\n * Retrieves the context types that have been registered for a given binding class.\n *\n * @param targetPrototype The class representing the binding (constructor function).\n *\n * @returns An array of [[ContextType]] that have been registered for the specified\n * binding class.\n */\n public getContextTypesForTarget(targetPrototype: any): ContextType[] {\n const targetBinding = this._targetBindings.get(targetPrototype);\n\n if (!targetBinding) {\n return [];\n }\n\n return targetBinding.contextTypes;\n }\n\n /**\n * Updates the binding registry indexes with a step binding.\n *\n * @param stepBinding The step binding that is to be registered with the binding registry.\n */\n public registerStepBinding(stepBinding: StepBinding): void {\n if (!stepBinding.tag) {\n stepBinding.tag = DEFAULT_TAG;\n }\n\n const stepPattern: StepPattern = stepBinding.stepPattern\n ? stepBinding.stepPattern.toString()\n : DEFAULT_STEP_PATTERN;\n\n let stepBindings = this._bindings.get(stepPattern);\n\n if (!stepBindings) {\n stepBindings = [];\n\n this._bindings.set(stepPattern, stepBindings);\n }\n\n logger.trace(\"Attempting to register step binding\", stepBinding);\n\n if (!stepBindings.some((b) => isSameStepBinding(stepBinding, b))) {\n logger.trace(\"Saving new step binding.\");\n stepBindings.push(stepBinding);\n }\n\n // Index the step binding for the target\n\n let targetBinding = this._targetBindings.get(stepBinding.targetPrototype);\n\n if (!targetBinding) {\n targetBinding = {\n stepBindings: [],\n contextTypes: [],\n };\n\n this._targetBindings.set(stepBinding.targetPrototype, targetBinding);\n }\n\n if (\n !targetBinding.stepBindings.some((b) => isSameStepBinding(stepBinding, b))\n ) {\n logger.trace(\"Saving new step binding to target.\");\n targetBinding.stepBindings.push(stepBinding);\n }\n\n logger.trace(\n \"All target step bindings\",\n targetBinding.stepBindings.map(\n (binding) => `${binding.stepPattern} ${binding.tag}`,\n ),\n );\n\n function isSameStepBinding(a: StepBinding, b: StepBinding) {\n return (\n a.callsite.filename === b.callsite.filename &&\n a.callsite.lineNumber === b.callsite.lineNumber &&\n String(a.stepPattern) === String(b.stepPattern) &&\n a.targetPropertyKey === b.targetPropertyKey\n );\n }\n }\n\n /**\n * Retrieves the step bindings that have been registered for a given binding class.\n *\n * @param targetPrototype The class representing the binding (constructor function).\n *\n * @returns An array of [[StepBinding]] objects that have been registered for the specified\n * binding class.\n */\n public getStepBindingsForTarget(targetPrototype: any): StepBinding[] {\n const targetBinding = this._targetBindings.get(targetPrototype);\n\n if (!targetBinding) {\n return [];\n }\n\n return targetBinding.stepBindings;\n }\n\n /**\n * Retrieves the step bindings for a given step pattern and collection of tag names.\n *\n * @param stepPattern The step pattern to search.\n *\n * @returns An array of [[StepBinding]] that map to the given step pattern and set of tag names.\n */\n public getStepBindings(stepPattern: StepPattern): StepBinding[] {\n return this._bindings.get(stepPattern) ?? [];\n }\n}\n"
},
{
"path": "cucumber-tsflow/src/hook-decorators.ts",
"content": "import {\n IDefineTestCaseHookOptions,\n IDefineTestRunHookOptions,\n IDefineTestStepHookOptions,\n} from \"@cucumber/cucumber/lib/support_code_library_builder/types\";\nimport { BindingRegistry } from \"./binding-registry\";\nimport { Callsite } from \"./our-callsite\";\nimport { StepBinding, StepBindingFlags } from \"./step-binding\";\nimport { normalizeTag } from \"./tag-normalization\";\n\n// Replace `tags` with `tag` for backwards compatibility\ntype HookOptions = Omit & {\n tag?: string;\n};\n\nfunction overloadedOption(tag?: string | HookOptions): HookOptions {\n if (tag === undefined || typeof tag === \"string\") {\n return { tag };\n }\n\n return tag;\n}\n\nfunction createHookDecorator(\n flag: StepBindingFlags,\n tagOrOption?: string | HookOptions,\n): MethodDecorator {\n const callsite = Callsite.capture(2);\n\n const { tag, timeout, ...hookOptions } = overloadedOption(tagOrOption);\n\n return (\n target: any,\n propertyKey: string | symbol,\n descriptor: TypedPropertyDescriptor,\n ) => {\n const stepBinding: StepBinding = {\n stepPattern: \"\",\n bindingType: flag,\n targetPrototype: target,\n targetPropertyKey: propertyKey,\n argsLength: target[propertyKey].length,\n tag: normalizeTag(tag),\n callsite: callsite,\n timeout: timeout,\n hookOptions: hookOptions,\n };\n\n BindingRegistry.instance.registerStepBinding(stepBinding);\n\n return descriptor;\n };\n}\n\n/**\n * A method decorator that marks the associated function as a 'Before Scenario' step. The function is\n * executed before each scenario.\n *\n * @param tagOrOption An optional tag or hook options object.\n */\nexport function before(tagOrOption?: string | HookOptions): MethodDecorator {\n return createHookDecorator(StepBindingFlags.before, tagOrOption);\n}\n\n/**\n * A method decorator that marks the associated function as an 'After Scenario' step. The function is\n * executed after each scenario.\n *\n * @param tagOrOption An optional tag or hook options object.\n */\nexport function after(tagOrOption?: string | HookOptions): MethodDecorator {\n return createHookDecorator(StepBindingFlags.after, tagOrOption);\n}\n\n/**\n * A method decorator that marks the associated function as a 'Before Scenario' step. The function is\n * executed before each scenario.\n *\n * @param options Optional hook options object.\n */\nexport function beforeAll(\n options?: IDefineTestRunHookOptions,\n): MethodDecorator {\n return createHookDecorator(StepBindingFlags.beforeAll, options);\n}\n\n/**\n * A method decorator that marks the associated function as an 'After Scenario' step. The function is\n * executed after each scenario.\n *\n * @param options Optional hook options object.\n */\nexport function afterAll(options?: IDefineTestRunHookOptions): MethodDecorator {\n return createHookDecorator(StepBindingFlags.afterAll, options);\n}\n\n/**\n * A method decorator that marks the associated function as a 'Before Step' step. The function is\n * executed before each step.\n *\n * @param options Optional hook options object.\n */\nexport function beforeStep(\n options?: IDefineTestStepHookOptions,\n): MethodDecorator {\n return createHookDecorator(StepBindingFlags.beforeStep, options);\n}\n\n/**\n * A method decorator that marks the associated function as an 'After Step' step. The function is\n * executed after each step.\n *\n * @param options Optional hook options object.\n */\nexport function afterStep(\n options?: IDefineTestStepHookOptions,\n): MethodDecorator {\n return createHookDecorator(StepBindingFlags.afterStep, options);\n}\n"
},
{
"path": "cucumber-tsflow/src/index.ts",
"content": "export * from \"./binding-decorator\";\nexport * from \"./hook-decorators\";\nexport * from \"./step-definition-decorators\";\nexport { ScenarioContext, ScenarioInfo } from \"./scenario-context\";\nexport * from \"./provided-context\";\n"
},
{
"path": "cucumber-tsflow/src/logger.ts",
"content": "import * as log4js from \"log4js\";\n\nconst logger = log4js.getLogger(\"cucumber-js.tsflow\");\n\nexport default logger;\n"
},
{
"path": "cucumber-tsflow/src/managed-scenario-context.ts",
"content": "import * as _ from \"underscore\";\nimport { BindingRegistry } from \"./binding-registry\";\nimport { ScenarioContext } from \"./scenario-context\";\nimport { ScenarioInfo } from \"./scenario-info\";\nimport { ContextType, isProvidedContextType } from \"./types\";\n\n/**\n * Represents a [[ScenarioContext]] implementation that manages a collection of context objects that\n * are created and used by binding classes during a running Cucumber scenario.\n */\nexport class ManagedScenarioContext implements ScenarioContext {\n private _activeObjects = new Map();\n\n constructor(private readonly _scenarioInfo: ScenarioInfo) {}\n\n /**\n * Gets information about the scenario.\n */\n public get scenarioInfo(): ScenarioInfo {\n return this._scenarioInfo;\n }\n\n public getOrActivateBindingClass(\n targetPrototype: any,\n contextTypes: ContextType[],\n ): any {\n return this.getOrActivateObject(targetPrototype, () => {\n return this.activateBindingClass(targetPrototype, contextTypes);\n });\n }\n\n public dispose(): void {\n this._activeObjects.forEach((value: any) => {\n if (typeof value.dispose === \"function\") {\n value.dispose();\n }\n });\n }\n\n /**\n * @internal\n */\n public getContextInstance(contextType: ContextType) {\n return this.getOrActivateObject(contextType.prototype, () => {\n if (isProvidedContextType(contextType)) {\n throw new Error(\n `The requested type \"${contextType.name}\" should be provided by cucumber-tsflow, but was not registered. Please report a bug.`,\n );\n }\n\n return new contextType();\n });\n }\n\n /**\n * @internal\n */\n public addExternalObject(value: unknown) {\n if (value == null) {\n return;\n }\n\n const proto = value.constructor.prototype;\n\n const existingObject = this._activeObjects.get(proto);\n\n if (existingObject !== undefined) {\n throw new Error(\n `Conflicting objects of type \"${proto.name}\" registered.`,\n );\n }\n\n this._activeObjects.set(proto, value);\n }\n\n private activateBindingClass(\n targetPrototype: any,\n contextTypes: ContextType[],\n ): any {\n const invokeBindingConstructor = (args: any[]): any => {\n return new (targetPrototype.constructor as any)(...args);\n };\n\n const contextObjects = _.map(contextTypes, (contextType) => {\n return this.getOrActivateBindingClass(\n contextType.prototype,\n BindingRegistry.instance.getContextTypesForTarget(\n contextType.prototype,\n ),\n );\n });\n\n return invokeBindingConstructor(contextObjects);\n }\n\n private getOrActivateObject(\n targetPrototype: any,\n activatorFunc: () => any,\n ): any {\n let activeObject = this._activeObjects.get(targetPrototype);\n\n if (activeObject) {\n return activeObject;\n }\n\n activeObject = activatorFunc();\n\n this._activeObjects.set(targetPrototype, activeObject);\n\n return activeObject;\n }\n}\n\nexport * from \"./scenario-context\";\n"
},
{
"path": "cucumber-tsflow/src/our-callsite.ts",
"content": "// @ts-ignore\nimport * as sourceMapSupport from \"source-map-support\";\n\n/**\n * Represents a callsite of where a step binding is being applied.\n */\nexport class Callsite {\n /**\n * Initializes a new [[Callsite]].\n *\n * @param filename The filename of the callsite.\n * @param lineNumber The line number of the callsite.\n */\n constructor(\n public filename: string,\n public lineNumber: number,\n ) {}\n\n /**\n * Captures the current [[Callsite]] object.\n */\n public static capture(up = 1): Callsite {\n const stack = callsites()[up + 1];\n const tsStack = sourceMapSupport.wrapCallSite(stack);\n return new Callsite(\n tsStack.getFileName() || \"\",\n tsStack.getLineNumber() || -1,\n );\n }\n\n /**\n * Returns a string representation of the callsite.\n *\n * @returns A string representing the callsite formatted with the filename and line\n * number.\n */\n public toString(): string {\n return `${this.filename}:${this.lineNumber}`;\n }\n}\n\nfunction callsites() {\n const _prepareStackTrace = Error.prepareStackTrace;\n try {\n let result: NodeJS.CallSite[] = [];\n Error.prepareStackTrace = (_, callSites) => {\n const callSitesWithoutCurrent = callSites.slice(1);\n result = callSitesWithoutCurrent;\n return callSitesWithoutCurrent;\n };\n\n new Error().stack; // eslint-disable-line unicorn/error-message, no-unused-expressions\n return result;\n } finally {\n Error.prepareStackTrace = _prepareStackTrace;\n }\n}\n"
},
{
"path": "cucumber-tsflow/src/provided-context.ts",
"content": "/* tslint:disable:max-classes-per-file */\nimport {\n ICreateAttachment,\n ICreateLog,\n} from \"@cucumber/cucumber/lib/runtime/attachment_manager\";\nimport { Readable } from \"stream\";\n\nexport class WorldParameters {\n public constructor(public readonly value: T) {}\n}\n\nexport class CucumberLog {\n public constructor(private readonly target: ICreateLog) {}\n\n public log(text: string): void | Promise {\n return this.target(text);\n }\n}\n\nexport class CucumberAttachments {\n public constructor(private readonly target: ICreateAttachment) {}\n\n public attach(data: string, mediaType?: string): void;\n public attach(data: Buffer, mediaType: string): void;\n public attach(data: Readable, mediaType: string): Promise;\n public attach(data: Readable, mediaType: string, callback: () => void): void;\n public attach(...args: any): void | Promise {\n return this.target.apply(this, args);\n }\n}\n"
},
{
"path": "cucumber-tsflow/src/scenario-context.ts",
"content": "import { ScenarioInfo } from \"./scenario-info\";\n\n/**\n * Provides context for the currently running Cucumber scenario.\n */\nexport interface ScenarioContext {\n /**\n * Gets information about the scenario.\n *\n */\n scenarioInfo: ScenarioInfo;\n\n /**\n * Gets or sets an arbitary object within the running scenario.\n */\n [key: string]: any;\n}\n\nexport * from \"./scenario-info\";\n"
},
{
"path": "cucumber-tsflow/src/scenario-info.ts",
"content": "import logger from \"./logger\";\nimport { TagName } from \"./types\";\n\n/**\n * Provides information about a running Cucumber scenario.\n */\nexport class ScenarioInfo {\n private _attributeTags?: Map;\n\n private _optionTags?: Map;\n\n private _flagTags?: Set;\n\n /**\n * Initializes the [[ScenarioInfo]] object.\n *\n * @param scenarioTitle The string title of the currently running Cucumber scenario.\n * @param tags An array of [[TagName]] representing the tags that are in scope for the currently\n * running Cucumber scenario.\n */\n constructor(\n public scenarioTitle: string,\n public tags: TagName[],\n ) {}\n\n private static parseAttributeTags(tags: TagName[]): Map {\n const RGX = /^@?(?[\\w-]+)\\((?.+?)\\)$/s;\n\n const result = new Map();\n\n for (const tag of tags) {\n const match = tag.match(RGX)?.groups;\n\n if (match !== undefined) {\n const { attributeName, value } = match;\n result.set(attributeName, JSON.parse(value));\n }\n }\n\n logger.trace(\"Parsed attribute tags\", { fromTags: tags, options: result });\n\n return result;\n }\n\n private static parseOptionTags(tags: TagName[]): Map {\n const RGX = /^@?(?