@step-forge/step-forge 0.0.7-beta.2 → 0.0.7-beta.3
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/types/index.d.ts +301 -0
- package/package.json +2 -2
|
@@ -0,0 +1,301 @@
|
|
|
1
|
+
export type EmptyObject = Record<string, never>;
|
|
2
|
+
export type RequiredOrOptional<T> = {
|
|
3
|
+
[K in keyof T]?: "required" | "optional";
|
|
4
|
+
};
|
|
5
|
+
export type GetFunctionArgs<T> = T extends (...args: infer A) => any ? A : never;
|
|
6
|
+
export type EmptyDependencies = {
|
|
7
|
+
given: EmptyObject;
|
|
8
|
+
when: EmptyObject;
|
|
9
|
+
then: EmptyObject;
|
|
10
|
+
};
|
|
11
|
+
export declare const givenBuilder: <GivenState>() => {
|
|
12
|
+
statement: <Statement extends ((...args: [
|
|
13
|
+
...any
|
|
14
|
+
]) => string) | string>(statement: Statement) => {
|
|
15
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
|
|
16
|
+
given: GivenDeps;
|
|
17
|
+
}) => {
|
|
18
|
+
step: (stepFunction: (input: {
|
|
19
|
+
variables: Statement extends string ? [
|
|
20
|
+
] : GetFunctionArgs<Statement>;
|
|
21
|
+
given: {
|
|
22
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
23
|
+
};
|
|
24
|
+
when: never;
|
|
25
|
+
then: never;
|
|
26
|
+
}) => Partial<GivenState>) => {
|
|
27
|
+
statement: Statement extends string ? () => string : Statement;
|
|
28
|
+
dependencies: {
|
|
29
|
+
given: GivenDeps;
|
|
30
|
+
} & {
|
|
31
|
+
when: EmptyObject;
|
|
32
|
+
then: EmptyObject;
|
|
33
|
+
};
|
|
34
|
+
stepType: "given";
|
|
35
|
+
stepFunction: (input: {
|
|
36
|
+
variables: Statement extends string ? [
|
|
37
|
+
] : GetFunctionArgs<Statement>;
|
|
38
|
+
given: {
|
|
39
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
40
|
+
};
|
|
41
|
+
when: never;
|
|
42
|
+
then: never;
|
|
43
|
+
}) => Partial<GivenState>;
|
|
44
|
+
register: () => {
|
|
45
|
+
stepType: "given";
|
|
46
|
+
dependencies: {
|
|
47
|
+
given: GivenDeps;
|
|
48
|
+
} & {
|
|
49
|
+
when: EmptyObject;
|
|
50
|
+
then: EmptyObject;
|
|
51
|
+
};
|
|
52
|
+
statement: Statement extends string ? () => string : Statement;
|
|
53
|
+
stepFunction: (input: {
|
|
54
|
+
variables: Statement extends string ? [
|
|
55
|
+
] : GetFunctionArgs<Statement>;
|
|
56
|
+
given: {
|
|
57
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
58
|
+
};
|
|
59
|
+
when: never;
|
|
60
|
+
then: never;
|
|
61
|
+
}) => Partial<GivenState>;
|
|
62
|
+
};
|
|
63
|
+
};
|
|
64
|
+
};
|
|
65
|
+
step: (stepFunction: (input: {
|
|
66
|
+
variables: Statement extends string ? [
|
|
67
|
+
] : GetFunctionArgs<Statement>;
|
|
68
|
+
given: never;
|
|
69
|
+
when: never;
|
|
70
|
+
then: never;
|
|
71
|
+
}) => Partial<GivenState>) => {
|
|
72
|
+
statement: Statement extends string ? () => string : Statement;
|
|
73
|
+
dependencies: EmptyDependencies;
|
|
74
|
+
stepType: "given";
|
|
75
|
+
stepFunction: (input: {
|
|
76
|
+
variables: Statement extends string ? [
|
|
77
|
+
] : GetFunctionArgs<Statement>;
|
|
78
|
+
given: never;
|
|
79
|
+
when: never;
|
|
80
|
+
then: never;
|
|
81
|
+
}) => Partial<GivenState>;
|
|
82
|
+
register: () => {
|
|
83
|
+
stepType: "given";
|
|
84
|
+
dependencies: EmptyDependencies;
|
|
85
|
+
statement: Statement extends string ? () => string : Statement;
|
|
86
|
+
stepFunction: (input: {
|
|
87
|
+
variables: Statement extends string ? [
|
|
88
|
+
] : GetFunctionArgs<Statement>;
|
|
89
|
+
given: never;
|
|
90
|
+
when: never;
|
|
91
|
+
then: never;
|
|
92
|
+
}) => Partial<GivenState>;
|
|
93
|
+
};
|
|
94
|
+
};
|
|
95
|
+
};
|
|
96
|
+
};
|
|
97
|
+
export declare const whenBuilder: <GivenState, WhenState>() => {
|
|
98
|
+
statement: <Statement extends ((...args: [
|
|
99
|
+
...any
|
|
100
|
+
]) => string) | string>(statement: Statement) => {
|
|
101
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
|
|
102
|
+
given?: GivenDeps | undefined;
|
|
103
|
+
when?: WhenDeps | undefined;
|
|
104
|
+
}) => {
|
|
105
|
+
step: (stepFunction: (input: {
|
|
106
|
+
variables: Statement extends string ? [
|
|
107
|
+
] : GetFunctionArgs<Statement>;
|
|
108
|
+
given: {
|
|
109
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
110
|
+
};
|
|
111
|
+
when: {
|
|
112
|
+
[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];
|
|
113
|
+
};
|
|
114
|
+
then: never;
|
|
115
|
+
}) => Partial<WhenState>) => {
|
|
116
|
+
statement: Statement extends string ? () => string : Statement;
|
|
117
|
+
dependencies: {
|
|
118
|
+
given: GivenDeps;
|
|
119
|
+
when: WhenDeps;
|
|
120
|
+
then: EmptyObject;
|
|
121
|
+
};
|
|
122
|
+
stepType: "when";
|
|
123
|
+
stepFunction: (input: {
|
|
124
|
+
variables: Statement extends string ? [
|
|
125
|
+
] : GetFunctionArgs<Statement>;
|
|
126
|
+
given: {
|
|
127
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
128
|
+
};
|
|
129
|
+
when: {
|
|
130
|
+
[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];
|
|
131
|
+
};
|
|
132
|
+
then: never;
|
|
133
|
+
}) => Partial<WhenState>;
|
|
134
|
+
register: () => {
|
|
135
|
+
stepType: "when";
|
|
136
|
+
dependencies: {
|
|
137
|
+
given: GivenDeps;
|
|
138
|
+
when: WhenDeps;
|
|
139
|
+
then: EmptyObject;
|
|
140
|
+
};
|
|
141
|
+
statement: Statement extends string ? () => string : Statement;
|
|
142
|
+
stepFunction: (input: {
|
|
143
|
+
variables: Statement extends string ? [
|
|
144
|
+
] : GetFunctionArgs<Statement>;
|
|
145
|
+
given: {
|
|
146
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
147
|
+
};
|
|
148
|
+
when: {
|
|
149
|
+
[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];
|
|
150
|
+
};
|
|
151
|
+
then: never;
|
|
152
|
+
}) => Partial<WhenState>;
|
|
153
|
+
};
|
|
154
|
+
};
|
|
155
|
+
};
|
|
156
|
+
step: (stepFunction: (input: {
|
|
157
|
+
variables: Statement extends string ? [
|
|
158
|
+
] : GetFunctionArgs<Statement>;
|
|
159
|
+
given: never;
|
|
160
|
+
when: never;
|
|
161
|
+
then: never;
|
|
162
|
+
}) => Partial<WhenState>) => {
|
|
163
|
+
statement: Statement extends string ? () => string : Statement;
|
|
164
|
+
dependencies: EmptyDependencies;
|
|
165
|
+
stepType: "when";
|
|
166
|
+
stepFunction: (input: {
|
|
167
|
+
variables: Statement extends string ? [
|
|
168
|
+
] : GetFunctionArgs<Statement>;
|
|
169
|
+
given: never;
|
|
170
|
+
when: never;
|
|
171
|
+
then: never;
|
|
172
|
+
}) => Partial<WhenState>;
|
|
173
|
+
register: () => {
|
|
174
|
+
stepType: "when";
|
|
175
|
+
dependencies: EmptyDependencies;
|
|
176
|
+
statement: Statement extends string ? () => string : Statement;
|
|
177
|
+
stepFunction: (input: {
|
|
178
|
+
variables: Statement extends string ? [
|
|
179
|
+
] : GetFunctionArgs<Statement>;
|
|
180
|
+
given: never;
|
|
181
|
+
when: never;
|
|
182
|
+
then: never;
|
|
183
|
+
}) => Partial<WhenState>;
|
|
184
|
+
};
|
|
185
|
+
};
|
|
186
|
+
};
|
|
187
|
+
};
|
|
188
|
+
export declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
|
|
189
|
+
statement: <Statement extends ((...args: [
|
|
190
|
+
...any
|
|
191
|
+
]) => string) | string>(statement: Statement) => {
|
|
192
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
|
|
193
|
+
given?: GivenDeps | undefined;
|
|
194
|
+
when?: WhenDeps | undefined;
|
|
195
|
+
then?: ThenDeps | undefined;
|
|
196
|
+
}) => {
|
|
197
|
+
step: (stepFunction: (input: {
|
|
198
|
+
variables: Statement extends string ? [
|
|
199
|
+
] : GetFunctionArgs<Statement>;
|
|
200
|
+
given: {
|
|
201
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
202
|
+
};
|
|
203
|
+
when: {
|
|
204
|
+
[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];
|
|
205
|
+
};
|
|
206
|
+
then: {
|
|
207
|
+
[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];
|
|
208
|
+
};
|
|
209
|
+
}) => void | Partial<ThenState>) => {
|
|
210
|
+
statement: Statement extends string ? () => string : Statement;
|
|
211
|
+
dependencies: {
|
|
212
|
+
given: GivenDeps;
|
|
213
|
+
when: WhenDeps;
|
|
214
|
+
then: ThenDeps;
|
|
215
|
+
};
|
|
216
|
+
stepType: "then";
|
|
217
|
+
stepFunction: (input: {
|
|
218
|
+
variables: Statement extends string ? [
|
|
219
|
+
] : GetFunctionArgs<Statement>;
|
|
220
|
+
given: {
|
|
221
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
222
|
+
};
|
|
223
|
+
when: {
|
|
224
|
+
[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];
|
|
225
|
+
};
|
|
226
|
+
then: {
|
|
227
|
+
[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];
|
|
228
|
+
};
|
|
229
|
+
}) => void | Partial<ThenState>;
|
|
230
|
+
register: () => {
|
|
231
|
+
stepType: "then";
|
|
232
|
+
dependencies: {
|
|
233
|
+
given: GivenDeps;
|
|
234
|
+
when: WhenDeps;
|
|
235
|
+
then: ThenDeps;
|
|
236
|
+
};
|
|
237
|
+
statement: Statement extends string ? () => string : Statement;
|
|
238
|
+
stepFunction: (input: {
|
|
239
|
+
variables: Statement extends string ? [
|
|
240
|
+
] : GetFunctionArgs<Statement>;
|
|
241
|
+
given: {
|
|
242
|
+
[K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K];
|
|
243
|
+
};
|
|
244
|
+
when: {
|
|
245
|
+
[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];
|
|
246
|
+
};
|
|
247
|
+
then: {
|
|
248
|
+
[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];
|
|
249
|
+
};
|
|
250
|
+
}) => void | Partial<ThenState>;
|
|
251
|
+
};
|
|
252
|
+
};
|
|
253
|
+
};
|
|
254
|
+
step: (stepFunction: (input: {
|
|
255
|
+
variables: Statement extends string ? [
|
|
256
|
+
] : GetFunctionArgs<Statement>;
|
|
257
|
+
given: never;
|
|
258
|
+
when: never;
|
|
259
|
+
then: never;
|
|
260
|
+
}) => void | Partial<ThenState>) => {
|
|
261
|
+
statement: Statement extends string ? () => string : Statement;
|
|
262
|
+
dependencies: EmptyDependencies;
|
|
263
|
+
stepType: "then";
|
|
264
|
+
stepFunction: (input: {
|
|
265
|
+
variables: Statement extends string ? [
|
|
266
|
+
] : GetFunctionArgs<Statement>;
|
|
267
|
+
given: never;
|
|
268
|
+
when: never;
|
|
269
|
+
then: never;
|
|
270
|
+
}) => void | Partial<ThenState>;
|
|
271
|
+
register: () => {
|
|
272
|
+
stepType: "then";
|
|
273
|
+
dependencies: EmptyDependencies;
|
|
274
|
+
statement: Statement extends string ? () => string : Statement;
|
|
275
|
+
stepFunction: (input: {
|
|
276
|
+
variables: Statement extends string ? [
|
|
277
|
+
] : GetFunctionArgs<Statement>;
|
|
278
|
+
given: never;
|
|
279
|
+
when: never;
|
|
280
|
+
then: never;
|
|
281
|
+
}) => void | Partial<ThenState>;
|
|
282
|
+
};
|
|
283
|
+
};
|
|
284
|
+
};
|
|
285
|
+
};
|
|
286
|
+
export type WorldState<State> = {
|
|
287
|
+
readonly [K in keyof State]?: State[K];
|
|
288
|
+
};
|
|
289
|
+
export type MergeableWorldState<T> = WorldState<T> & {
|
|
290
|
+
merge: (newState: Partial<T>) => void;
|
|
291
|
+
};
|
|
292
|
+
export declare class BasicWorld<Given, When, Then> {
|
|
293
|
+
private givenState;
|
|
294
|
+
private whenState;
|
|
295
|
+
private thenState;
|
|
296
|
+
get given(): MergeableWorldState<Given>;
|
|
297
|
+
get when(): MergeableWorldState<When>;
|
|
298
|
+
get then(): MergeableWorldState<Then>;
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
export {};
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@step-forge/step-forge",
|
|
3
|
-
"version": "0.0.7-beta.
|
|
3
|
+
"version": "0.0.7-beta.3",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"exports": {
|
|
6
6
|
".": {
|
|
@@ -18,7 +18,7 @@
|
|
|
18
18
|
],
|
|
19
19
|
"scripts": {
|
|
20
20
|
"dev": "vite --host",
|
|
21
|
-
"build": "rimraf dist && tsc && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.
|
|
21
|
+
"build": "rimraf dist && tsc && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.cjs",
|
|
22
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",
|
|
23
23
|
"test:ci": "NODE_ENV=test cucumber-js -p ci",
|
|
24
24
|
"test": "NODE_ENV=test PORT=7888 LOG_LEVEL=none cucumber-js -p all 2> /dev/null",
|