@step-forge/step-forge 0.0.6 → 0.0.7-beta

package/dist/types/src/builderTypeUtils.d.ts

@@ -0,0 +1,14 @@
+export type StepType = "given" | "when" | "then";
+export type InferAndReplace<T, U> = never extends T ? U : T;
+export type HasKeys<T> = T extends Record<any, any> ? (keyof T extends never ? never : T) : T;
+export type EmptyObject = Record<string, never>;
+export type RequiredOrOptional<T> = {
+    [K in keyof T]?: "required" | "optional";
+};
+export type GetFunctionArgs<T> = T extends (...args: infer A) => any ? A : never;
+export declare const isString: (statement: string | ((...args: [...any]) => string)) => statement is string;
+export type EmptyDependencies = {
+    given: EmptyObject;
+    when: EmptyObject;
+    then: EmptyObject;
+};

package/dist/types/src/common.d.ts

@@ -0,0 +1,32 @@
+import { StepType } from "./builderTypeUtils";
+export declare const addStep: <ResolvedStepType extends StepType, Statement extends (...args: any[]) => string, Dependencies extends {
+    given: any;
+    when: any;
+    then: any;
+}, Variables, GivenState, WhenState, ThenState, RestrictedGivenState, RestrictedWhenState, RestrictedThenState>(statement: Statement, stepType: ResolvedStepType, dependencies?: Dependencies) => (stepFunction: (input: {
+    variables: Variables;
+    given: RestrictedGivenState;
+    when: RestrictedWhenState;
+    then: RestrictedThenState;
+}) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void) => {
+    statement: Statement;
+    dependencies: Dependencies;
+    stepType: ResolvedStepType;
+    stepFunction: (input: {
+        variables: Variables;
+        given: RestrictedGivenState;
+        when: RestrictedWhenState;
+        then: RestrictedThenState;
+    }) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
+    register: () => {
+        stepType: ResolvedStepType;
+        dependencies: Dependencies;
+        statement: Statement;
+        stepFunction: (input: {
+            variables: Variables;
+            given: RestrictedGivenState;
+            when: RestrictedWhenState;
+            then: RestrictedThenState;
+        }) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
+    };
+};

package/dist/types/src/given.d.ts

@@ -0,0 +1,73 @@
+import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
+export declare const givenBuilder: <GivenState>() => {
+    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
+            given: GivenDeps;
+        }) => {
+            step: (stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                when: never;
+                then: never;
+            }) => Partial<GivenState>) => {
+                statement: Statement extends string ? () => string : Statement;
+                dependencies: {
+                    given: GivenDeps;
+                } & {
+                    when: EmptyObject;
+                    then: EmptyObject;
+                };
+                stepType: "given";
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                    when: never;
+                    then: never;
+                }) => Partial<GivenState>;
+                register: () => {
+                    stepType: "given";
+                    dependencies: {
+                        given: GivenDeps;
+                    } & {
+                        when: EmptyObject;
+                        then: EmptyObject;
+                    };
+                    statement: Statement extends string ? () => string : Statement;
+                    stepFunction: (input: {
+                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                        when: never;
+                        then: never;
+                    }) => Partial<GivenState>;
+                };
+            };
+        };
+        step: (stepFunction: (input: {
+            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+            given: never;
+            when: never;
+            then: never;
+        }) => Partial<GivenState>) => {
+            statement: Statement extends string ? () => string : Statement;
+            dependencies: EmptyDependencies;
+            stepType: "given";
+            stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: never;
+                when: never;
+                then: never;
+            }) => Partial<GivenState>;
+            register: () => {
+                stepType: "given";
+                dependencies: EmptyDependencies;
+                statement: Statement extends string ? () => string : Statement;
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: never;
+                    when: never;
+                    then: never;
+                }) => Partial<GivenState>;
+            };
+        };
+    };
+};

package/{src/index.ts → dist/types/src/index.d.ts}

@@ -2,5 +2,4 @@ import { givenBuilder } from "./given";
 import { whenBuilder } from "./when";
 import { thenBuilder } from "./then";
 import { BasicWorld } from "./world";
-
 export { givenBuilder, whenBuilder, thenBuilder, BasicWorld };

package/dist/types/src/then.d.ts

@@ -0,0 +1,73 @@
+import { EmptyDependencies, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
+export declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
+    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
+            given?: GivenDeps | undefined;
+            when?: WhenDeps | undefined;
+            then?: ThenDeps | undefined;
+        }) => {
+            step: (stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
+            }) => void | Partial<ThenState>) => {
+                statement: Statement extends string ? () => string : Statement;
+                dependencies: {
+                    given: GivenDeps;
+                    when: WhenDeps;
+                    then: ThenDeps;
+                };
+                stepType: "then";
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                    when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                    then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
+                }) => void | Partial<ThenState>;
+                register: () => {
+                    stepType: "then";
+                    dependencies: {
+                        given: GivenDeps;
+                        when: WhenDeps;
+                        then: ThenDeps;
+                    };
+                    statement: Statement extends string ? () => string : Statement;
+                    stepFunction: (input: {
+                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                        then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
+                    }) => void | Partial<ThenState>;
+                };
+            };
+        };
+        step: (stepFunction: (input: {
+            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+            given: never;
+            when: never;
+            then: never;
+        }) => void | Partial<ThenState>) => {
+            statement: Statement extends string ? () => string : Statement;
+            dependencies: EmptyDependencies;
+            stepType: "then";
+            stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: never;
+                when: never;
+                then: never;
+            }) => void | Partial<ThenState>;
+            register: () => {
+                stepType: "then";
+                dependencies: EmptyDependencies;
+                statement: Statement extends string ? () => string : Statement;
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: never;
+                    when: never;
+                    then: never;
+                }) => void | Partial<ThenState>;
+            };
+        };
+    };
+};

package/dist/types/src/utils.d.ts

@@ -0,0 +1,5 @@
+import { MergeableWorld } from "./world";
+export declare const requireFromGiven: <G>(keys: (keyof G)[], world: MergeableWorld<G, unknown, unknown>) => { [key in keyof G]: G[key]; };
+export declare const requireFromWhen: <W>(keys: (keyof W)[], world: MergeableWorld<unknown, W, unknown>) => { [key in keyof W]: W[key]; };
+export declare const requireFromThen: <T>(keys: (keyof T)[], world: MergeableWorld<unknown, unknown, T>) => { [key in keyof T]: T[key]; };
+export declare const typeCoercer: (value: string) => string | number | boolean;

package/dist/types/src/when.d.ts

@@ -0,0 +1,72 @@
+import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
+export declare const whenBuilder: <GivenState, WhenState>() => {
+    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
+            given?: GivenDeps | undefined;
+            when?: WhenDeps | undefined;
+        }) => {
+            step: (stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                then: never;
+            }) => Partial<WhenState>) => {
+                statement: Statement extends string ? () => string : Statement;
+                dependencies: {
+                    given: GivenDeps;
+                    when: WhenDeps;
+                    then: EmptyObject;
+                };
+                stepType: "when";
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                    when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                    then: never;
+                }) => Partial<WhenState>;
+                register: () => {
+                    stepType: "when";
+                    dependencies: {
+                        given: GivenDeps;
+                        when: WhenDeps;
+                        then: EmptyObject;
+                    };
+                    statement: Statement extends string ? () => string : Statement;
+                    stepFunction: (input: {
+                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
+                        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
+                        then: never;
+                    }) => Partial<WhenState>;
+                };
+            };
+        };
+        step: (stepFunction: (input: {
+            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+            given: never;
+            when: never;
+            then: never;
+        }) => Partial<WhenState>) => {
+            statement: Statement extends string ? () => string : Statement;
+            dependencies: EmptyDependencies;
+            stepType: "when";
+            stepFunction: (input: {
+                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                given: never;
+                when: never;
+                then: never;
+            }) => Partial<WhenState>;
+            register: () => {
+                stepType: "when";
+                dependencies: EmptyDependencies;
+                statement: Statement extends string ? () => string : Statement;
+                stepFunction: (input: {
+                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+                    given: never;
+                    when: never;
+                    then: never;
+                }) => Partial<WhenState>;
+            };
+        };
+    };
+};

package/dist/types/src/world.d.ts

@@ -0,0 +1,21 @@
+export type WorldState<State> = {
+    readonly [K in keyof State]?: State[K];
+};
+export type MergeableWorldState<T> = WorldState<T> & {
+    merge: (newState: Partial<T>) => void;
+};
+export declare const createMergeableState: <T>(state: WorldState<T>) => MergeableWorldState<T>;
+export type MergeableWorld<Given, When, Then> = {
+    given: MergeableWorldState<Given>;
+    when: MergeableWorldState<When>;
+    then: MergeableWorldState<Then>;
+};
+export declare class BasicWorld<Given, When, Then> {
+    private givenState;
+    private whenState;
+    private thenState;
+    get given(): MergeableWorldState<Given>;
+    get when(): MergeableWorldState<When>;
+    get then(): MergeableWorldState<Then>;
+}
+export declare const createBasicWorld: <Given, When, Then>() => MergeableWorld<Given, When, Then>;

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@step-forge/step-forge",
-  "version": "0.0.6",
-  "module": "./dist/step-forge.js",
+  "version": "0.0.7-beta",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/step-forge.js"
-    },
-    "./dist/": {
-      "import": "./dist/"
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/step-forge.js",
+      "default": "./dist/step-forge.js"
     }
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "dev": "vite --host",
-    "build": "rimraf build/**/* && rimraf dist/**/* && tsc && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.ts && copyfiles -u 1 \"dist/**/*\" \"package.json\" build",
+    "build": "rimraf dist && tsc --emitDeclarationOnly --outDir dist/types && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.ts",
     "test:cucumber": "NODE_ENV=test NODE_OPTIONS=\"--experimental-specifier-resolution=node --loader ts-node/esm\" TS_NODE_PROJECT=./tsconfig.cucumber.json cucumber-js -p default",
     "test:ci": "NODE_ENV=test cucumber-js -p ci",
     "test": "NODE_ENV=test PORT=7888 LOG_LEVEL=none cucumber-js -p all 2> /dev/null",

package/.eslintignore

@@ -1,6 +0,0 @@
-.history
-.husky
-.vscode
-coverage
-dist
-node_modules

package/.eslintrc

@@ -1,18 +0,0 @@
-{
-  "root": true,
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint", "prettier"],
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier"
-  ],
-  "env": {
-    "browser": true,
-    "node": true
-  },
-  "rules": {
-    "prettier/prettier": "error"
-  }
-}

package/.prettierignore

@@ -1,6 +0,0 @@
-.history
-.husky
-.vscode
-coverage
-dist
-node_modules

package/.prettierrc

@@ -1,15 +0,0 @@
-{
-  "printWidth": 80,
-  "tabWidth": 2,
-  "singleQuote": false,
-  "trailingComma": "es5",
-  "arrowParens": "avoid",
-  "bracketSpacing": true,
-  "useTabs": false,
-  "endOfLine": "auto",
-  "singleAttributePerLine": false,
-  "bracketSameLine": false,
-  "jsxSingleQuote": false,
-  "quoteProps": "as-needed",
-  "semi": true
-}

package/CHANGELOG.md

@@ -1,28 +0,0 @@
-# Change Log
-
-All notable changes to the "@step-forge/step-forge" project will be documented in this file.
-
-## [0.0.5] - 2024-12-31
-
-- Add support for exporting steps
-
-## [0.0.4] - 2024-07-30
-
-- Update all packages to the latest versions
-- Remove support for CommonJS modules
-
-## [0.0.3] - 2024-01-23
-
-- Update all packages to the latest versions (update to vite 5.x)
-
-## [0.0.2] - 2023-01-18
-
-- Update all packages to the latest versions (update to vite 4.x)
-
-## [0.0.1] - 2022-09-08
-
-- Update all packages to the latest versions (update to vite 3.x)
-
-## [0.0.0] - 2022-03-28
-
-- Initial release

package/cucumber.mjs

@@ -1,38 +0,0 @@
-const defaultProfile = {
-  format: [
-    process.env.CI || !process.stdout.isTTY ? "progress" : "progress-bar",
-    "json:./reports/cucumber-json-reports/report.json",
-    "rerun:./reports/cucumber/@rerun.txt",
-    "usage:./reports/cucumber/usage.txt",
-  ],
-  parallel: 1,
-  importModule: ["ts-node/esm", "tsconfig-paths/register"],
-  import: [
-    "./features/steps/**/*.ts",
-    "./features/steps/*.ts",
-    "./src/**/*.ts",
-  ],
-  strict: false,
-};
-
-const ciProfile = {
-  format: [
-    process.env.CI || !process.stdout.isTTY ? "progress" : "progress-bar",
-    "json:./reports/cucumber-json-reports/report.json",
-    "rerun:./reports/cucumber/@rerun.txt",
-    "usage:./reports/cucumber/usage.txt",
-  ],
-  parallel: 1,
-  importModule: ["ts-node/register/transpile-only", "tsconfig-paths/register"],
-  import: ["./features/steps/**/*.ts", "./features/steps/*.ts"],
-  strict: false,
-  publish: true,
-};
-
-const all = {
-  ...defaultProfile,
-  paths: ["./features"],
-};
-
-export { ciProfile as ci, all };
-export default defaultProfile;

package/dts-bundle-generator.config.ts

@@ -1,11 +0,0 @@
-const config = {
-  entries: [
-    {
-      filePath: "./src/index.ts",
-      outFile: "./build/dist/index.d.ts",
-      noCheck: false,
-    },
-  ],
-};
-
-module.exports = config;

package/features/basic.feature

@@ -1,21 +0,0 @@
-Feature: Steps written in gherkin can be matched to Step Forge steps
-
-    Scenario: Basic feature steps with no dependencies or variables can be run as a cucumber scenario
-        Given I started
-        When I got here
-        Then everything was good
-
-    Scenario: Basic feature steps with dependencies can be run as a cucumber scenario
-        Given a user
-        When I save the user
-        Then there is a user
-
-    Scenario: Basic feature steps with variables can be run as a cucumber scenario
-        Given a user named "John"
-        When I save the user
-        Then there is a user
-
-    Scenario: Basic feature steps with dependencies and variables can be run as a cucumber scenario
-        Given a user
-        When I name the user "John"
-        Then the user's name is "John"

package/features/exported.feature

@@ -1,6 +0,0 @@
-Feature: Builders can be re-exported for ease of use
-
-    Scenario: Exported steps can be used in cucumber scenarios
-        Given a bank user
-        When I deposit "1000" "USD"
-        Then the balance is "1000"

package/features/steps/commonSteps.ts

@@ -1,93 +0,0 @@
-import { givenBuilder } from "../../src/given";
-import { whenBuilder } from "../../src/when";
-import { thenBuilder } from "../../src/then";
-import { GivenState, ThenState, WhenState } from "./world";
-import { expect } from "earl";
-
-// --- No dependency no variable steps --- //
-givenBuilder<GivenState>()
-  .statement("I started")
-  .step(() => ({}))
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I got here")
-  .step(() => ({}))
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("everything was good")
-  .step(() => ({}))
-  .register();
-
-// --- Dependency only steps --- //
-givenBuilder<GivenState>()
-  .statement("a user")
-  .step(() => {
-    return {
-      user: {
-        type: "person",
-        token: "random",
-      },
-    };
-  })
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I save the user")
-  .dependencies({ given: { user: "required" } })
-  .step(({ given: { user } }) => {
-    return {
-      user: {
-        ...user,
-        saved: true,
-      },
-    };
-  })
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("there is a user")
-  .dependencies({ when: { user: "required" } })
-  .step(({ when: { user } }) => {
-    expect(user.saved).toBeTruthy();
-  })
-  .register();
-
-// --- Variable only steps --- //
-givenBuilder<GivenState>()
-  .statement((userName: string) => `a user named ${userName}`)
-  .step(({ variables: [userName] }) => {
-    return {
-      user: {
-        type: "person",
-        token: userName,
-      },
-    };
-  })
-  .register();
-
-// --- More complex steps --- //
-
-whenBuilder<GivenState, WhenState>()
-  .statement((userName: string) => `I name the user ${userName}`)
-  .dependencies({ given: { user: "required" } })
-  .step(({ given: { user }, variables: [userName] }) => {
-    return {
-      user: {
-        ...user,
-        token: userName,
-        saved: true,
-      },
-    };
-  })
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement((userName: string) => `the user's name is ${userName}`)
-  .dependencies({ when: { user: "required" } })
-  .step(({ when: { user }, variables: [userName] }) => {
-    const token = user.token;
-    expect(token).toEqual(userName);
-  })
-  .register();

package/features/steps/exportedSteps.ts

@@ -1,42 +0,0 @@
-import { expect } from "earl";
-import { givenBuilder } from "../../src/given";
-import { thenBuilder } from "../../src/then";
-import { whenBuilder } from "../../src/when";
-import { GivenState, ThenState, WhenState } from "./world";
-
-const Given = givenBuilder<GivenState>().statement;
-const When = whenBuilder<GivenState, WhenState>().statement;
-const Then = thenBuilder<GivenState, WhenState, ThenState>().statement;
-
-Given("a bank user")
-  .step(() => {
-    return {
-      user: {
-        type: "customer",
-        token: "random",
-      },
-    };
-  })
-  .register();
-
-When((amount: string, currency: string) => `I deposit ${amount} ${currency}`)
-  .dependencies({ given: { user: "required" } })
-  .step(({ variables: [rawAmount, currency], given: { user } }) => {
-    const amount = parseFloat(rawAmount);
-    return {
-      deposit: {
-        amount,
-        currency,
-        user,
-      },
-    };
-  })
-  .register();
-
-Then((amount: string) => `the balance is ${amount}`)
-  .dependencies({ when: { deposit: "required" } })
-  .step(({ when: { deposit }, variables: [rawAmount] }) => {
-    const amount = parseFloat(rawAmount);
-    expect(deposit.amount).toEqual(amount);
-  })
-  .register();

package/features/steps/world.ts

@@ -1,29 +0,0 @@
-import { setWorldConstructor } from "@cucumber/cucumber";
-import { BasicWorld } from "../../src/world";
-
-export interface GivenState {
-  user: {
-    type: string;
-    token: string;
-  };
-}
-
-export interface WhenState {
-  user: {
-    type: string;
-    token: string;
-    saved: boolean;
-  };
-  deposit: {
-    amount: number;
-    currency: string;
-    user: {
-      type: string;
-      token: string;
-    };
-  };
-}
-
-export interface ThenState {}
-
-setWorldConstructor(BasicWorld<GivenState, WhenState, ThenState>);