@step-forge/step-forge 0.0.7-beta.6 → 0.0.7

package/dist/step-forge.js

@@ -1,180 +1,199 @@
-var z = Object.defineProperty;
-var B = (n, e, t) => e in n ? z(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var o = (n, e, t) => B(n, typeof e != "symbol" ? e + "" : e, t);
-import { Then as A, When as C, Given as M } from "@cucumber/cucumber";
-import c from "lodash";
-const a = (n) => typeof n == "string", j = (n, e) => (n.forEach((t) => {
-  if (!e.given[t])
+var C = Object.defineProperty;
+var _ = (e, n, t) => n in e ? C(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
+var u = (e, n, t) => _(e, typeof n != "symbol" ? n + "" : n, t);
+import { Then as x, When as I, Given as y } from "@cucumber/cucumber";
+import h from "lodash";
+const v = (e) => typeof e == "string", H = (e, n) => (e.forEach((t) => {
+  if (!n.given[t])
     throw new Error(`Key ${String(t)} is required in given state`);
-}), n.reduce(
+}), e.reduce(
   (t, r) => ({
     ...t,
-    [r]: e.given[r]
+    [r]: n.given[r]
   }),
   {}
-)), N = (n, e) => (n.forEach((t) => {
-  if (!e.when[t])
+)), J = (e, n) => (e.forEach((t) => {
+  if (!n.when[t])
     throw new Error(`Key ${String(t)} is required in when state`);
-}), n.reduce(
+}), e.reduce(
   (t, r) => ({
     ...t,
-    [r]: e.when[r]
+    [r]: n.when[r]
   }),
   {}
-)), P = (n, e) => (n.forEach((t) => {
-  if (!e.then[t])
+)), L = (e, n) => (e.forEach((t) => {
+  if (!n.then[t])
     throw new Error(`Key ${String(t)} is required in then state`);
-}), n.reduce(
+}), e.reduce(
   (t, r) => ({
     ...t,
-    [r]: e.then[r]
+    [r]: n.then[r]
   }),
   {}
-)), x = (n) => {
-  const e = parseInt(n, 10);
-  return isNaN(e) ? n === "true" ? !0 : n === "false" ? !1 : n : e;
-}, I = {
-  given: M,
-  when: C,
-  then: A
-}, h = (n, e, t = {
+)), N = {
+  parse: (e) => e,
+  gherkin: "{string}"
+}, te = {
+  parse: (e) => parseInt(e, 10),
+  gherkin: "{int}"
+}, re = {
+  parse: (e) => parseFloat(e),
+  gherkin: "{double}"
+}, ie = {
+  parse: (e) => e === "true",
+  gherkin: "{string}"
+}, Q = {
+  given: y,
+  when: I,
+  then: x
+}, c = (e, n, t = {
   given: {},
   when: {},
   then: {}
-}) => (r) => {
-  const s = n, {
-    given: g,
-    when: d,
-    then: w
+}, r) => (s) => {
+  const o = e, {
+    given: w,
+    when: l,
+    then: f
   } = t;
   return {
-    statement: n,
+    statement: e,
     dependencies: t,
-    stepType: e,
-    stepFunction: r,
+    stepType: n,
+    stepFunction: s,
     register: () => {
-      const f = s.length, m = Array.from({ length: f }, () => "{string}"), v = s(...m), l = Object.defineProperty(
+      const a = o.length, m = r ?? Array.from({ length: a }, () => N), D = Array.from({ length: a }, (p, g) => m[g].gherkin), P = o(...D), O = Object.defineProperty(
         async function(...p) {
-          const q = p.map(x), F = Object.entries(g ?? {}).filter(([, i]) => i === "required").map(([i]) => i), D = j(
-            F,
-            this
-          ), O = {
-            ...c.pick(this.given, Object.keys(g ?? {})),
-            ...D
-          }, E = Object.entries(d ?? {}).filter(([, i]) => i === "required").map(([i]) => i), K = N(
+          const g = p.filter((i) => typeof i != "function").map((i, k) => m[k].parse(i)), E = Object.entries(w ?? {}).filter(([, i]) => i === "required").map(([i]) => i), K = H(
             E,
             this
           ), W = {
-            ...c.pick(this.when, Object.keys(d ?? {})),
+            ...h.pick(this.given, Object.keys(w ?? {})),
             ...K
-          }, b = Object.entries(w ?? {}).filter(([, i]) => i === "required").map(([i]) => i), G = P(
-            b,
+          }, G = Object.entries(l ?? {}).filter(([, i]) => i === "required").map(([i]) => i), $ = J(
+            G,
+            this
+          ), z = {
+            ...h.pick(this.when, Object.keys(l ?? {})),
+            ...$
+          }, A = Object.entries(f ?? {}).filter(([, i]) => i === "required").map(([i]) => i), B = L(
+            A,
             this
-          ), $ = {
-            ...c.pick(this.then, Object.keys(w ?? {})),
-            ...G
-          }, y = await r({
-            variables: q,
-            given: O,
-            when: W,
-            then: $
+          ), M = {
+            ...h.pick(this.then, Object.keys(f ?? {})),
+            ...B
+          }, j = await s({
+            variables: g,
+            given: W,
+            when: z,
+            then: M
           });
-          this[e].merge({
-            ...y
+          this[n].merge({
+            ...j
           });
         },
         "length",
-        { value: f, configurable: !0 }
-      ), S = I[e];
-      return S(v, l), {
-        stepType: e,
+        { value: a, configurable: !0 }
+      ), b = Q[n];
+      return b(P, O), {
+        stepType: n,
         dependencies: t,
-        statement: s,
-        stepFunction: r
+        statement: o,
+        stepFunction: s
       };
     }
   };
-}, _ = (n, e) => (t) => {
-  const r = {
-    ...t,
+}, S = (e, n, t) => (r) => {
+  const s = {
+    ...r,
     when: {},
     then: {}
   };
   return {
-    step: h(n, e, r)
+    step: c(e, n, s, t)
   };
-}, H = (n) => (e) => {
+}, R = (e, n) => (t) => ({
+  dependencies: S(e, n, t),
+  step: c(e, n, void 0, t)
+}), U = (e) => (n) => {
   let t;
-  a(e) ? t = () => e : t = e;
-  const r = _(t, n), s = h(t, n);
-  return {
-    dependencies: r,
-    step: s
+  return v(n) ? t = () => n : t = n, {
+    dependencies: S(t, e),
+    parsers: R(t, e),
+    step: c(t, e)
   };
-}, Z = () => ({
-  statement: H("given")
-}), J = (n, e) => (t) => {
-  const r = {
-    given: t.given ?? {},
-    when: t.when ?? {},
+}, se = () => ({
+  statement: U("given")
+}), F = (e, n, t) => (r) => {
+  const s = {
+    given: r.given ?? {},
+    when: r.when ?? {},
     then: {}
   };
   return {
-    step: h(n, e, r)
+    step: c(e, n, s, t)
   };
-}, L = (n) => (e) => {
+}, X = (e, n) => (t) => ({
+  dependencies: F(e, n, t),
+  step: c(e, n, void 0, t)
+}), Y = (e) => (n) => {
   let t;
-  a(e) ? t = () => e : t = e;
-  const r = J(t, n), s = h(t, n);
+  v(n) ? t = () => n : t = n;
+  const r = F(t, e), s = X(t, e), o = c(t, e);
   return {
     dependencies: r,
-    step: s
+    parsers: s,
+    step: o
   };
-}, T = () => ({
-  statement: L("when")
-}), Q = (n, e) => (t) => {
-  const r = {
-    given: t.given ?? {},
-    when: t.when ?? {},
-    then: t.then ?? {}
+}, ce = () => ({
+  statement: Y("when")
+}), q = (e, n, t) => (r) => {
+  const s = {
+    given: r.given ?? {},
+    when: r.when ?? {},
+    then: r.then ?? {}
   };
   return {
-    step: h(n, e, r)
+    step: c(e, n, s, t)
   };
-}, R = (n) => (e) => {
+}, Z = (e, n) => (t) => ({
+  dependencies: q(e, n, t),
+  step: c(e, n, void 0, t)
+}), V = (e) => (n) => {
   let t;
-  a(e) ? t = () => e : t = e;
-  const r = Q(t, n), s = h(t, n);
+  v(n) ? t = () => n : t = n;
+  const r = q(t, e), s = c(t, e), o = Z(t, e);
   return {
     dependencies: r,
+    parsers: o,
     step: s
   };
-}, k = () => ({
-  statement: R("then")
+}, he = () => ({
+  statement: V("then")
 });
-function u(n, e) {
-  if (c.isArray(n))
-    return n.concat(e);
-  if (n && !c.isPlainObject(n) && n !== e)
+function d(e, n) {
+  if (h.isArray(e))
+    return e.concat(n);
+  if (e && !h.isPlainObject(e) && e !== n)
     throw new Error(
-      `Merge would have destroyed previous value ${n} with ${e}`
+      `Merge would have destroyed previous value ${e} with ${n}`
     );
-  return n;
+  return e;
 }
-class V {
+class oe {
   constructor() {
-    o(this, "givenState", {});
-    o(this, "whenState", {});
-    o(this, "thenState", {});
+    u(this, "givenState", {});
+    u(this, "whenState", {});
+    u(this, "thenState", {});
   }
   get given() {
     return {
       ...this.givenState,
-      merge: (e) => {
-        this.givenState = c.merge(
+      merge: (n) => {
+        this.givenState = h.merge(
           { ...this.givenState },
-          e,
-          u
+          n,
+          d
         );
       }
     };
@@ -182,11 +201,11 @@ class V {
   get when() {
     return {
       ...this.whenState,
-      merge: (e) => {
-        this.whenState = c.merge(
+      merge: (n) => {
+        this.whenState = h.merge(
           { ...this.whenState },
-          e,
-          u
+          n,
+          d
         );
       }
     };
@@ -194,19 +213,23 @@ class V {
   get then() {
     return {
       ...this.thenState,
-      merge: (e) => {
-        this.thenState = c.merge(
+      merge: (n) => {
+        this.thenState = h.merge(
           { ...this.thenState },
-          e,
-          u
+          n,
+          d
         );
       }
     };
   }
 }
 export {
-  V as BasicWorld,
-  Z as givenBuilder,
-  k as thenBuilder,
-  T as whenBuilder
+  oe as BasicWorld,
+  ie as booleanParser,
+  se as givenBuilder,
+  te as intParser,
+  re as numberParser,
+  N as stringParser,
+  he as thenBuilder,
+  ce as whenBuilder
 };

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/dist/types/src/index.d.ts

@@ -0,0 +1,5 @@
+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>;