@step-forge/step-forge 0.0.7-beta → 0.0.7-beta.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/step-forge.js +212 -0
- package/package.json +6 -3
- package/dist/types/src/builderTypeUtils.d.ts +0 -14
- package/dist/types/src/common.d.ts +0 -32
- package/dist/types/src/given.d.ts +0 -73
- package/dist/types/src/index.d.ts +0 -5
- package/dist/types/src/then.d.ts +0 -73
- package/dist/types/src/utils.d.ts +0 -5
- package/dist/types/src/when.d.ts +0 -72
- package/dist/types/src/world.d.ts +0 -21
|
@@ -0,0 +1,212 @@
|
|
|
1
|
+
var z = Object.defineProperty;
|
|
2
|
+
var B = (n, e, t) => e in n ? z(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
|
|
3
|
+
var o = (n, e, t) => B(n, typeof e != "symbol" ? e + "" : e, t);
|
|
4
|
+
import { Then as A, When as C, Given as M } from "@cucumber/cucumber";
|
|
5
|
+
import c from "lodash";
|
|
6
|
+
const a = (n) => typeof n == "string", j = (n, e) => (n.forEach((t) => {
|
|
7
|
+
if (!e.given[t])
|
|
8
|
+
throw new Error(`Key ${String(t)} is required in given state`);
|
|
9
|
+
}), n.reduce(
|
|
10
|
+
(t, r) => ({
|
|
11
|
+
...t,
|
|
12
|
+
[r]: e.given[r]
|
|
13
|
+
}),
|
|
14
|
+
{}
|
|
15
|
+
)), N = (n, e) => (n.forEach((t) => {
|
|
16
|
+
if (!e.when[t])
|
|
17
|
+
throw new Error(`Key ${String(t)} is required in when state`);
|
|
18
|
+
}), n.reduce(
|
|
19
|
+
(t, r) => ({
|
|
20
|
+
...t,
|
|
21
|
+
[r]: e.when[r]
|
|
22
|
+
}),
|
|
23
|
+
{}
|
|
24
|
+
)), P = (n, e) => (n.forEach((t) => {
|
|
25
|
+
if (!e.then[t])
|
|
26
|
+
throw new Error(`Key ${String(t)} is required in then state`);
|
|
27
|
+
}), n.reduce(
|
|
28
|
+
(t, r) => ({
|
|
29
|
+
...t,
|
|
30
|
+
[r]: e.then[r]
|
|
31
|
+
}),
|
|
32
|
+
{}
|
|
33
|
+
)), x = (n) => {
|
|
34
|
+
const e = parseInt(n, 10);
|
|
35
|
+
return isNaN(e) ? n === "true" ? !0 : n === "false" ? !1 : n : e;
|
|
36
|
+
}, I = {
|
|
37
|
+
given: M,
|
|
38
|
+
when: C,
|
|
39
|
+
then: A
|
|
40
|
+
}, h = (n, e, t = {
|
|
41
|
+
given: {},
|
|
42
|
+
when: {},
|
|
43
|
+
then: {}
|
|
44
|
+
}) => (r) => {
|
|
45
|
+
const s = n, {
|
|
46
|
+
given: g,
|
|
47
|
+
when: d,
|
|
48
|
+
then: w
|
|
49
|
+
} = t;
|
|
50
|
+
return {
|
|
51
|
+
statement: n,
|
|
52
|
+
dependencies: t,
|
|
53
|
+
stepType: e,
|
|
54
|
+
stepFunction: r,
|
|
55
|
+
register: () => {
|
|
56
|
+
const f = s.length, m = Array.from({ length: f }, () => "{string}"), v = s(...m), l = Object.defineProperty(
|
|
57
|
+
async function(...p) {
|
|
58
|
+
const q = p.map(x), F = Object.entries(g ?? {}).filter(([, i]) => i === "required").map(([i]) => i), D = j(
|
|
59
|
+
F,
|
|
60
|
+
this
|
|
61
|
+
), O = {
|
|
62
|
+
...c.pick(this.given, Object.keys(g ?? {})),
|
|
63
|
+
...D
|
|
64
|
+
}, E = Object.entries(d ?? {}).filter(([, i]) => i === "required").map(([i]) => i), K = N(
|
|
65
|
+
E,
|
|
66
|
+
this
|
|
67
|
+
), W = {
|
|
68
|
+
...c.pick(this.when, Object.keys(d ?? {})),
|
|
69
|
+
...K
|
|
70
|
+
}, b = Object.entries(w ?? {}).filter(([, i]) => i === "required").map(([i]) => i), G = P(
|
|
71
|
+
b,
|
|
72
|
+
this
|
|
73
|
+
), $ = {
|
|
74
|
+
...c.pick(this.then, Object.keys(w ?? {})),
|
|
75
|
+
...G
|
|
76
|
+
}, y = await r({
|
|
77
|
+
variables: q,
|
|
78
|
+
given: O,
|
|
79
|
+
when: W,
|
|
80
|
+
then: $
|
|
81
|
+
});
|
|
82
|
+
this[e].merge({
|
|
83
|
+
...y
|
|
84
|
+
});
|
|
85
|
+
},
|
|
86
|
+
"length",
|
|
87
|
+
{ value: f, configurable: !0 }
|
|
88
|
+
), S = I[e];
|
|
89
|
+
return S(v, l), {
|
|
90
|
+
stepType: e,
|
|
91
|
+
dependencies: t,
|
|
92
|
+
statement: s,
|
|
93
|
+
stepFunction: r
|
|
94
|
+
};
|
|
95
|
+
}
|
|
96
|
+
};
|
|
97
|
+
}, _ = (n, e) => (t) => {
|
|
98
|
+
const r = {
|
|
99
|
+
...t,
|
|
100
|
+
when: {},
|
|
101
|
+
then: {}
|
|
102
|
+
};
|
|
103
|
+
return {
|
|
104
|
+
step: h(n, e, r)
|
|
105
|
+
};
|
|
106
|
+
}, H = (n) => (e) => {
|
|
107
|
+
let t;
|
|
108
|
+
a(e) ? t = () => e : t = e;
|
|
109
|
+
const r = _(t, n), s = h(t, n);
|
|
110
|
+
return {
|
|
111
|
+
dependencies: r,
|
|
112
|
+
step: s
|
|
113
|
+
};
|
|
114
|
+
}, Z = () => ({
|
|
115
|
+
statement: H("given")
|
|
116
|
+
}), J = (n, e) => (t) => {
|
|
117
|
+
const r = {
|
|
118
|
+
given: t.given ?? {},
|
|
119
|
+
when: t.when ?? {},
|
|
120
|
+
then: {}
|
|
121
|
+
};
|
|
122
|
+
return {
|
|
123
|
+
step: h(n, e, r)
|
|
124
|
+
};
|
|
125
|
+
}, L = (n) => (e) => {
|
|
126
|
+
let t;
|
|
127
|
+
a(e) ? t = () => e : t = e;
|
|
128
|
+
const r = J(t, n), s = h(t, n);
|
|
129
|
+
return {
|
|
130
|
+
dependencies: r,
|
|
131
|
+
step: s
|
|
132
|
+
};
|
|
133
|
+
}, T = () => ({
|
|
134
|
+
statement: L("when")
|
|
135
|
+
}), Q = (n, e) => (t) => {
|
|
136
|
+
const r = {
|
|
137
|
+
given: t.given ?? {},
|
|
138
|
+
when: t.when ?? {},
|
|
139
|
+
then: t.then ?? {}
|
|
140
|
+
};
|
|
141
|
+
return {
|
|
142
|
+
step: h(n, e, r)
|
|
143
|
+
};
|
|
144
|
+
}, R = (n) => (e) => {
|
|
145
|
+
let t;
|
|
146
|
+
a(e) ? t = () => e : t = e;
|
|
147
|
+
const r = Q(t, n), s = h(t, n);
|
|
148
|
+
return {
|
|
149
|
+
dependencies: r,
|
|
150
|
+
step: s
|
|
151
|
+
};
|
|
152
|
+
}, k = () => ({
|
|
153
|
+
statement: R("then")
|
|
154
|
+
});
|
|
155
|
+
function u(n, e) {
|
|
156
|
+
if (c.isArray(n))
|
|
157
|
+
return n.concat(e);
|
|
158
|
+
if (n && !c.isPlainObject(n) && n !== e)
|
|
159
|
+
throw new Error(
|
|
160
|
+
`Merge would have destroyed previous value ${n} with ${e}`
|
|
161
|
+
);
|
|
162
|
+
return n;
|
|
163
|
+
}
|
|
164
|
+
class V {
|
|
165
|
+
constructor() {
|
|
166
|
+
o(this, "givenState", {});
|
|
167
|
+
o(this, "whenState", {});
|
|
168
|
+
o(this, "thenState", {});
|
|
169
|
+
}
|
|
170
|
+
get given() {
|
|
171
|
+
return {
|
|
172
|
+
...this.givenState,
|
|
173
|
+
merge: (e) => {
|
|
174
|
+
this.givenState = c.merge(
|
|
175
|
+
{ ...this.givenState },
|
|
176
|
+
e,
|
|
177
|
+
u
|
|
178
|
+
);
|
|
179
|
+
}
|
|
180
|
+
};
|
|
181
|
+
}
|
|
182
|
+
get when() {
|
|
183
|
+
return {
|
|
184
|
+
...this.whenState,
|
|
185
|
+
merge: (e) => {
|
|
186
|
+
this.whenState = c.merge(
|
|
187
|
+
{ ...this.whenState },
|
|
188
|
+
e,
|
|
189
|
+
u
|
|
190
|
+
);
|
|
191
|
+
}
|
|
192
|
+
};
|
|
193
|
+
}
|
|
194
|
+
get then() {
|
|
195
|
+
return {
|
|
196
|
+
...this.thenState,
|
|
197
|
+
merge: (e) => {
|
|
198
|
+
this.thenState = c.merge(
|
|
199
|
+
{ ...this.thenState },
|
|
200
|
+
e,
|
|
201
|
+
u
|
|
202
|
+
);
|
|
203
|
+
}
|
|
204
|
+
};
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
export {
|
|
208
|
+
V as BasicWorld,
|
|
209
|
+
Z as givenBuilder,
|
|
210
|
+
k as thenBuilder,
|
|
211
|
+
T as whenBuilder
|
|
212
|
+
};
|
package/package.json
CHANGED
|
@@ -1,21 +1,24 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@step-forge/step-forge",
|
|
3
|
-
"version": "0.0.7-beta",
|
|
3
|
+
"version": "0.0.7-beta.2",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"exports": {
|
|
6
6
|
".": {
|
|
7
7
|
"types": "./dist/types/index.d.ts",
|
|
8
8
|
"import": "./dist/step-forge.js",
|
|
9
9
|
"default": "./dist/step-forge.js"
|
|
10
|
-
}
|
|
10
|
+
},
|
|
11
|
+
"./package.json": "./package.json"
|
|
11
12
|
},
|
|
13
|
+
"main": "./dist/step-forge.js",
|
|
14
|
+
"module": "./dist/step-forge.js",
|
|
12
15
|
"types": "./dist/types/index.d.ts",
|
|
13
16
|
"files": [
|
|
14
17
|
"dist"
|
|
15
18
|
],
|
|
16
19
|
"scripts": {
|
|
17
20
|
"dev": "vite --host",
|
|
18
|
-
"build": "rimraf dist && tsc
|
|
21
|
+
"build": "rimraf dist && tsc && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.ts --output ./dist/types/index.d.ts",
|
|
19
22
|
"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",
|
|
20
23
|
"test:ci": "NODE_ENV=test cucumber-js -p ci",
|
|
21
24
|
"test": "NODE_ENV=test PORT=7888 LOG_LEVEL=none cucumber-js -p all 2> /dev/null",
|
|
@@ -1,14 +0,0 @@
|
|
|
1
|
-
export type StepType = "given" | "when" | "then";
|
|
2
|
-
export type InferAndReplace<T, U> = never extends T ? U : T;
|
|
3
|
-
export type HasKeys<T> = T extends Record<any, any> ? (keyof T extends never ? never : T) : T;
|
|
4
|
-
export type EmptyObject = Record<string, never>;
|
|
5
|
-
export type RequiredOrOptional<T> = {
|
|
6
|
-
[K in keyof T]?: "required" | "optional";
|
|
7
|
-
};
|
|
8
|
-
export type GetFunctionArgs<T> = T extends (...args: infer A) => any ? A : never;
|
|
9
|
-
export declare const isString: (statement: string | ((...args: [...any]) => string)) => statement is string;
|
|
10
|
-
export type EmptyDependencies = {
|
|
11
|
-
given: EmptyObject;
|
|
12
|
-
when: EmptyObject;
|
|
13
|
-
then: EmptyObject;
|
|
14
|
-
};
|
|
@@ -1,32 +0,0 @@
|
|
|
1
|
-
import { StepType } from "./builderTypeUtils";
|
|
2
|
-
export declare const addStep: <ResolvedStepType extends StepType, Statement extends (...args: any[]) => string, Dependencies extends {
|
|
3
|
-
given: any;
|
|
4
|
-
when: any;
|
|
5
|
-
then: any;
|
|
6
|
-
}, Variables, GivenState, WhenState, ThenState, RestrictedGivenState, RestrictedWhenState, RestrictedThenState>(statement: Statement, stepType: ResolvedStepType, dependencies?: Dependencies) => (stepFunction: (input: {
|
|
7
|
-
variables: Variables;
|
|
8
|
-
given: RestrictedGivenState;
|
|
9
|
-
when: RestrictedWhenState;
|
|
10
|
-
then: RestrictedThenState;
|
|
11
|
-
}) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void) => {
|
|
12
|
-
statement: Statement;
|
|
13
|
-
dependencies: Dependencies;
|
|
14
|
-
stepType: ResolvedStepType;
|
|
15
|
-
stepFunction: (input: {
|
|
16
|
-
variables: Variables;
|
|
17
|
-
given: RestrictedGivenState;
|
|
18
|
-
when: RestrictedWhenState;
|
|
19
|
-
then: RestrictedThenState;
|
|
20
|
-
}) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
|
|
21
|
-
register: () => {
|
|
22
|
-
stepType: ResolvedStepType;
|
|
23
|
-
dependencies: Dependencies;
|
|
24
|
-
statement: Statement;
|
|
25
|
-
stepFunction: (input: {
|
|
26
|
-
variables: Variables;
|
|
27
|
-
given: RestrictedGivenState;
|
|
28
|
-
when: RestrictedWhenState;
|
|
29
|
-
then: RestrictedThenState;
|
|
30
|
-
}) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
|
|
31
|
-
};
|
|
32
|
-
};
|
|
@@ -1,73 +0,0 @@
|
|
|
1
|
-
import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
|
|
2
|
-
export declare const givenBuilder: <GivenState>() => {
|
|
3
|
-
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
4
|
-
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
|
|
5
|
-
given: GivenDeps;
|
|
6
|
-
}) => {
|
|
7
|
-
step: (stepFunction: (input: {
|
|
8
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
9
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
10
|
-
when: never;
|
|
11
|
-
then: never;
|
|
12
|
-
}) => Partial<GivenState>) => {
|
|
13
|
-
statement: Statement extends string ? () => string : Statement;
|
|
14
|
-
dependencies: {
|
|
15
|
-
given: GivenDeps;
|
|
16
|
-
} & {
|
|
17
|
-
when: EmptyObject;
|
|
18
|
-
then: EmptyObject;
|
|
19
|
-
};
|
|
20
|
-
stepType: "given";
|
|
21
|
-
stepFunction: (input: {
|
|
22
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
23
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
24
|
-
when: never;
|
|
25
|
-
then: never;
|
|
26
|
-
}) => Partial<GivenState>;
|
|
27
|
-
register: () => {
|
|
28
|
-
stepType: "given";
|
|
29
|
-
dependencies: {
|
|
30
|
-
given: GivenDeps;
|
|
31
|
-
} & {
|
|
32
|
-
when: EmptyObject;
|
|
33
|
-
then: EmptyObject;
|
|
34
|
-
};
|
|
35
|
-
statement: Statement extends string ? () => string : Statement;
|
|
36
|
-
stepFunction: (input: {
|
|
37
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
38
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
39
|
-
when: never;
|
|
40
|
-
then: never;
|
|
41
|
-
}) => Partial<GivenState>;
|
|
42
|
-
};
|
|
43
|
-
};
|
|
44
|
-
};
|
|
45
|
-
step: (stepFunction: (input: {
|
|
46
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
47
|
-
given: never;
|
|
48
|
-
when: never;
|
|
49
|
-
then: never;
|
|
50
|
-
}) => Partial<GivenState>) => {
|
|
51
|
-
statement: Statement extends string ? () => string : Statement;
|
|
52
|
-
dependencies: EmptyDependencies;
|
|
53
|
-
stepType: "given";
|
|
54
|
-
stepFunction: (input: {
|
|
55
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
56
|
-
given: never;
|
|
57
|
-
when: never;
|
|
58
|
-
then: never;
|
|
59
|
-
}) => Partial<GivenState>;
|
|
60
|
-
register: () => {
|
|
61
|
-
stepType: "given";
|
|
62
|
-
dependencies: EmptyDependencies;
|
|
63
|
-
statement: Statement extends string ? () => string : Statement;
|
|
64
|
-
stepFunction: (input: {
|
|
65
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
66
|
-
given: never;
|
|
67
|
-
when: never;
|
|
68
|
-
then: never;
|
|
69
|
-
}) => Partial<GivenState>;
|
|
70
|
-
};
|
|
71
|
-
};
|
|
72
|
-
};
|
|
73
|
-
};
|
package/dist/types/src/then.d.ts
DELETED
|
@@ -1,73 +0,0 @@
|
|
|
1
|
-
import { EmptyDependencies, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
|
|
2
|
-
export declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
|
|
3
|
-
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
4
|
-
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
|
|
5
|
-
given?: GivenDeps | undefined;
|
|
6
|
-
when?: WhenDeps | undefined;
|
|
7
|
-
then?: ThenDeps | undefined;
|
|
8
|
-
}) => {
|
|
9
|
-
step: (stepFunction: (input: {
|
|
10
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
11
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
12
|
-
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]; };
|
|
13
|
-
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]; };
|
|
14
|
-
}) => void | Partial<ThenState>) => {
|
|
15
|
-
statement: Statement extends string ? () => string : Statement;
|
|
16
|
-
dependencies: {
|
|
17
|
-
given: GivenDeps;
|
|
18
|
-
when: WhenDeps;
|
|
19
|
-
then: ThenDeps;
|
|
20
|
-
};
|
|
21
|
-
stepType: "then";
|
|
22
|
-
stepFunction: (input: {
|
|
23
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
24
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
25
|
-
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]; };
|
|
26
|
-
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]; };
|
|
27
|
-
}) => void | Partial<ThenState>;
|
|
28
|
-
register: () => {
|
|
29
|
-
stepType: "then";
|
|
30
|
-
dependencies: {
|
|
31
|
-
given: GivenDeps;
|
|
32
|
-
when: WhenDeps;
|
|
33
|
-
then: ThenDeps;
|
|
34
|
-
};
|
|
35
|
-
statement: Statement extends string ? () => string : Statement;
|
|
36
|
-
stepFunction: (input: {
|
|
37
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
38
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
39
|
-
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]; };
|
|
40
|
-
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]; };
|
|
41
|
-
}) => void | Partial<ThenState>;
|
|
42
|
-
};
|
|
43
|
-
};
|
|
44
|
-
};
|
|
45
|
-
step: (stepFunction: (input: {
|
|
46
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
47
|
-
given: never;
|
|
48
|
-
when: never;
|
|
49
|
-
then: never;
|
|
50
|
-
}) => void | Partial<ThenState>) => {
|
|
51
|
-
statement: Statement extends string ? () => string : Statement;
|
|
52
|
-
dependencies: EmptyDependencies;
|
|
53
|
-
stepType: "then";
|
|
54
|
-
stepFunction: (input: {
|
|
55
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
56
|
-
given: never;
|
|
57
|
-
when: never;
|
|
58
|
-
then: never;
|
|
59
|
-
}) => void | Partial<ThenState>;
|
|
60
|
-
register: () => {
|
|
61
|
-
stepType: "then";
|
|
62
|
-
dependencies: EmptyDependencies;
|
|
63
|
-
statement: Statement extends string ? () => string : Statement;
|
|
64
|
-
stepFunction: (input: {
|
|
65
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
66
|
-
given: never;
|
|
67
|
-
when: never;
|
|
68
|
-
then: never;
|
|
69
|
-
}) => void | Partial<ThenState>;
|
|
70
|
-
};
|
|
71
|
-
};
|
|
72
|
-
};
|
|
73
|
-
};
|
|
@@ -1,5 +0,0 @@
|
|
|
1
|
-
import { MergeableWorld } from "./world";
|
|
2
|
-
export declare const requireFromGiven: <G>(keys: (keyof G)[], world: MergeableWorld<G, unknown, unknown>) => { [key in keyof G]: G[key]; };
|
|
3
|
-
export declare const requireFromWhen: <W>(keys: (keyof W)[], world: MergeableWorld<unknown, W, unknown>) => { [key in keyof W]: W[key]; };
|
|
4
|
-
export declare const requireFromThen: <T>(keys: (keyof T)[], world: MergeableWorld<unknown, unknown, T>) => { [key in keyof T]: T[key]; };
|
|
5
|
-
export declare const typeCoercer: (value: string) => string | number | boolean;
|
package/dist/types/src/when.d.ts
DELETED
|
@@ -1,72 +0,0 @@
|
|
|
1
|
-
import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
|
|
2
|
-
export declare const whenBuilder: <GivenState, WhenState>() => {
|
|
3
|
-
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
4
|
-
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
|
|
5
|
-
given?: GivenDeps | undefined;
|
|
6
|
-
when?: WhenDeps | undefined;
|
|
7
|
-
}) => {
|
|
8
|
-
step: (stepFunction: (input: {
|
|
9
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
10
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
11
|
-
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]; };
|
|
12
|
-
then: never;
|
|
13
|
-
}) => Partial<WhenState>) => {
|
|
14
|
-
statement: Statement extends string ? () => string : Statement;
|
|
15
|
-
dependencies: {
|
|
16
|
-
given: GivenDeps;
|
|
17
|
-
when: WhenDeps;
|
|
18
|
-
then: EmptyObject;
|
|
19
|
-
};
|
|
20
|
-
stepType: "when";
|
|
21
|
-
stepFunction: (input: {
|
|
22
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
23
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
24
|
-
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]; };
|
|
25
|
-
then: never;
|
|
26
|
-
}) => Partial<WhenState>;
|
|
27
|
-
register: () => {
|
|
28
|
-
stepType: "when";
|
|
29
|
-
dependencies: {
|
|
30
|
-
given: GivenDeps;
|
|
31
|
-
when: WhenDeps;
|
|
32
|
-
then: EmptyObject;
|
|
33
|
-
};
|
|
34
|
-
statement: Statement extends string ? () => string : Statement;
|
|
35
|
-
stepFunction: (input: {
|
|
36
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
37
|
-
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
|
|
38
|
-
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]; };
|
|
39
|
-
then: never;
|
|
40
|
-
}) => Partial<WhenState>;
|
|
41
|
-
};
|
|
42
|
-
};
|
|
43
|
-
};
|
|
44
|
-
step: (stepFunction: (input: {
|
|
45
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
46
|
-
given: never;
|
|
47
|
-
when: never;
|
|
48
|
-
then: never;
|
|
49
|
-
}) => Partial<WhenState>) => {
|
|
50
|
-
statement: Statement extends string ? () => string : Statement;
|
|
51
|
-
dependencies: EmptyDependencies;
|
|
52
|
-
stepType: "when";
|
|
53
|
-
stepFunction: (input: {
|
|
54
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
55
|
-
given: never;
|
|
56
|
-
when: never;
|
|
57
|
-
then: never;
|
|
58
|
-
}) => Partial<WhenState>;
|
|
59
|
-
register: () => {
|
|
60
|
-
stepType: "when";
|
|
61
|
-
dependencies: EmptyDependencies;
|
|
62
|
-
statement: Statement extends string ? () => string : Statement;
|
|
63
|
-
stepFunction: (input: {
|
|
64
|
-
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
65
|
-
given: never;
|
|
66
|
-
when: never;
|
|
67
|
-
then: never;
|
|
68
|
-
}) => Partial<WhenState>;
|
|
69
|
-
};
|
|
70
|
-
};
|
|
71
|
-
};
|
|
72
|
-
};
|
|
@@ -1,21 +0,0 @@
|
|
|
1
|
-
export type WorldState<State> = {
|
|
2
|
-
readonly [K in keyof State]?: State[K];
|
|
3
|
-
};
|
|
4
|
-
export type MergeableWorldState<T> = WorldState<T> & {
|
|
5
|
-
merge: (newState: Partial<T>) => void;
|
|
6
|
-
};
|
|
7
|
-
export declare const createMergeableState: <T>(state: WorldState<T>) => MergeableWorldState<T>;
|
|
8
|
-
export type MergeableWorld<Given, When, Then> = {
|
|
9
|
-
given: MergeableWorldState<Given>;
|
|
10
|
-
when: MergeableWorldState<When>;
|
|
11
|
-
then: MergeableWorldState<Then>;
|
|
12
|
-
};
|
|
13
|
-
export declare class BasicWorld<Given, When, Then> {
|
|
14
|
-
private givenState;
|
|
15
|
-
private whenState;
|
|
16
|
-
private thenState;
|
|
17
|
-
get given(): MergeableWorldState<Given>;
|
|
18
|
-
get when(): MergeableWorldState<When>;
|
|
19
|
-
get then(): MergeableWorldState<Then>;
|
|
20
|
-
}
|
|
21
|
-
export declare const createBasicWorld: <Given, When, Then>() => MergeableWorld<Given, When, Then>;
|