piral-forms 1.10.3 → 1.11.0-beta.1bddd86

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.
Files changed (2) hide show
  1. package/package.json +3 -3
  2. package/src/useForm.test.ts +403 -451
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "piral-forms",
3
- "version": "1.10.3",
3
+ "version": "1.11.0-beta.1bddd86",
4
4
  "description": "Plugin for providing advanced form support in Piral.",
5
5
  "keywords": [
6
6
  "piral",
@@ -52,8 +52,8 @@
52
52
  "@types/history": "^4.7.8",
53
53
  "@types/react": "^18.0.0",
54
54
  "@types/react-router-dom": "^5.1.6",
55
- "piral-core": "^1.10.3",
55
+ "piral-core": "1.11.0-beta.1bddd86",
56
56
  "react": "^18.0.0"
57
57
  },
58
- "gitHead": "d01fa2763b3ef45efc823c148cf7198e105387de"
58
+ "gitHead": "1bddd8699e357ceedfd2da226a48e4d3d9152578"
59
59
  }
package/src/useForm.test.ts CHANGED
@@ -30,494 +30,446 @@ describe('Form Hook Module', () => {
30
30
  setStateFake.mockReset();
31
31
  });
32
32
 
33
- it(
34
- 'Returns the current data and not changed initially',
35
- async () => {
36
- const { useForm } = await import('./useForm');
33
+ it('Returns the current data and not changed initially', testOptions, async () => {
34
+ const { useForm } = await import('./useForm');
37
35
 
38
- useGlobalState.mockImplementation((select: any) =>
39
- select({
40
- forms: {
41
- foo: {
42
- changed: false,
43
- currentData: {},
44
- initialData: {},
45
- submitting: false,
46
- error: undefined,
47
- },
36
+ useGlobalState.mockImplementation((select: any) =>
37
+ select({
38
+ forms: {
39
+ foo: {
40
+ changed: false,
41
+ currentData: {},
42
+ initialData: {},
43
+ submitting: false,
44
+ error: undefined,
48
45
  },
49
- }),
50
- );
51
-
52
- const options = {
53
- wait: false,
54
- silent: false,
55
- message: '',
56
- onSubmit() {
57
- return Promise.resolve();
58
46
  },
59
- onChange: undefined,
60
- emptyData: {},
61
- };
62
- const { changed, submitting, formData } = useForm({}, undefined as any, options, 'foo');
63
- expect(changed).toBeFalsy();
64
- expect(submitting).toBeFalsy();
65
- expect(formData).toEqual({});
66
- expect(setStateFake.mock.calls[0][0].length).toBe(3);
67
- },
68
- testOptions,
69
- );
47
+ }),
48
+ );
70
49
 
71
- it(
72
- 'Generates a new id if the old one is not provided',
73
- async () => {
74
- const { useForm } = await import('./useForm');
50
+ const options = {
51
+ wait: false,
52
+ silent: false,
53
+ message: '',
54
+ onSubmit() {
55
+ return Promise.resolve();
56
+ },
57
+ onChange: undefined,
58
+ emptyData: {},
59
+ };
60
+ const { changed, submitting, formData } = useForm({}, undefined as any, options, 'foo');
61
+ expect(changed).toBeFalsy();
62
+ expect(submitting).toBeFalsy();
63
+ expect(formData).toEqual({});
64
+ expect(setStateFake.mock.calls[0][0].length).toBe(3);
65
+ });
75
66
 
76
- useGlobalState.mockImplementation((select: any) =>
77
- select({
78
- forms: {},
79
- }),
80
- );
81
- const options = {
82
- wait: false,
83
- silent: false,
84
- message: '',
85
- onSubmit() {
86
- return Promise.resolve();
87
- },
88
- onChange: undefined,
89
- emptyData: {},
90
- };
91
- const { changed, submitting, formData } = useForm({}, undefined as any, options);
92
- expect(changed).toBeFalsy();
93
- expect(submitting).toBeFalsy();
94
- expect(formData).toEqual({});
95
- expect(setStateFake.mock.calls[0][0].length).toBe(36);
96
- },
97
- testOptions,
98
- );
67
+ it('Generates a new id if the old one is not provided', testOptions, async () => {
68
+ const { useForm } = await import('./useForm');
99
69
 
100
- it(
101
- 'Submit with no changed data does nothing',
102
- async () => {
103
- const { useForm } = await import('./useForm');
104
- const onSubmit = vitest.fn(() => Promise.resolve());
70
+ useGlobalState.mockImplementation((select: any) =>
71
+ select({
72
+ forms: {},
73
+ }),
74
+ );
75
+ const options = {
76
+ wait: false,
77
+ silent: false,
78
+ message: '',
79
+ onSubmit() {
80
+ return Promise.resolve();
81
+ },
82
+ onChange: undefined,
83
+ emptyData: {},
84
+ };
85
+ const { changed, submitting, formData } = useForm({}, undefined as any, options);
86
+ expect(changed).toBeFalsy();
87
+ expect(submitting).toBeFalsy();
88
+ expect(formData).toEqual({});
89
+ expect(setStateFake.mock.calls[0][0].length).toBe(36);
90
+ });
105
91
 
106
- useGlobalState.mockImplementation((select: any) =>
107
- select({
108
- forms: {},
109
- }),
110
- );
111
- const options = {
112
- wait: false,
113
- silent: false,
114
- message: '',
115
- onSubmit,
116
- onChange: undefined,
117
- emptyData: {},
118
- };
119
- const { changed, submitting, formData, submit } = useForm({}, undefined as any, options);
120
- submit();
121
- expect(changed).toBeFalsy();
122
- expect(submitting).toBeFalsy();
123
- expect(onSubmit).not.toHaveBeenCalled();
124
- expect(formData).toEqual({});
125
- expect(setStateFake.mock.calls[0][0].length).toBe(36);
126
- },
127
- testOptions,
128
- );
92
+ it('Submit with no changed data does nothing', testOptions, async () => {
93
+ const { useForm } = await import('./useForm');
94
+ const onSubmit = vitest.fn(() => Promise.resolve());
129
95
 
130
- it(
131
- 'Submit with no changed data does something with allowSubmitUnchanged is on',
132
- async () => {
133
- const { useForm } = await import('./useForm');
134
- const onSubmit = vitest.fn(() => Promise.resolve());
96
+ useGlobalState.mockImplementation((select: any) =>
97
+ select({
98
+ forms: {},
99
+ }),
100
+ );
101
+ const options = {
102
+ wait: false,
103
+ silent: false,
104
+ message: '',
105
+ onSubmit,
106
+ onChange: undefined,
107
+ emptyData: {},
108
+ };
109
+ const { changed, submitting, formData, submit } = useForm({}, undefined as any, options);
110
+ submit();
111
+ expect(changed).toBeFalsy();
112
+ expect(submitting).toBeFalsy();
113
+ expect(onSubmit).not.toHaveBeenCalled();
114
+ expect(formData).toEqual({});
115
+ expect(setStateFake.mock.calls[0][0].length).toBe(36);
116
+ });
117
+
118
+ it('Submit with no changed data does something with allowSubmitUnchanged is on', testOptions, async () => {
119
+ const { useForm } = await import('./useForm');
120
+ const onSubmit = vitest.fn(() => Promise.resolve());
135
121
 
136
- useGlobalState.mockImplementation((select: any) =>
137
- select({
138
- forms: {},
139
- }),
140
- );
141
- const options = {
142
- allowSubmitUnchanged: true,
143
- wait: false,
144
- silent: false,
145
- message: '',
146
- onSubmit,
147
- onChange: undefined,
148
- emptyData: {},
149
- };
150
- const { changed, submitting, formData, submit } = useForm({}, undefined as any, options);
151
- submit();
152
- expect(changed).toBeFalsy();
153
- expect(submitting).toBeFalsy();
154
- expect(onSubmit).toHaveBeenCalled();
155
- expect(formData).toEqual({});
156
- expect(setStateFake.mock.calls[0][0].length).toBe(36);
157
- },
158
- testOptions,
159
- );
122
+ useGlobalState.mockImplementation((select: any) =>
123
+ select({
124
+ forms: {},
125
+ }),
126
+ );
127
+ const options = {
128
+ allowSubmitUnchanged: true,
129
+ wait: false,
130
+ silent: false,
131
+ message: '',
132
+ onSubmit,
133
+ onChange: undefined,
134
+ emptyData: {},
135
+ };
136
+ const { changed, submitting, formData, submit } = useForm({}, undefined as any, options);
137
+ submit();
138
+ expect(changed).toBeFalsy();
139
+ expect(submitting).toBeFalsy();
140
+ expect(onSubmit).toHaveBeenCalled();
141
+ expect(formData).toEqual({});
142
+ expect(setStateFake.mock.calls[0][0].length).toBe(36);
143
+ });
160
144
 
161
- it(
162
- 'Submit with changed data submits successfully',
163
- async () => {
164
- const { useForm } = await import('./useForm');
165
- const onSubmit = vitest.fn(() => Promise.resolve());
145
+ it('Submit with changed data submits successfully', testOptions, async () => {
146
+ const { useForm } = await import('./useForm');
147
+ const onSubmit = vitest.fn(() => Promise.resolve());
166
148
 
167
- useGlobalState.mockImplementation((select: any) =>
168
- select({
169
- forms: {
170
- foo: {
171
- changed: true,
172
- currentData: {
173
- a: 'foo',
174
- },
175
- initialData: {
176
- a: '',
177
- },
178
- submitting: false,
179
- error: undefined,
149
+ useGlobalState.mockImplementation((select: any) =>
150
+ select({
151
+ forms: {
152
+ foo: {
153
+ changed: true,
154
+ currentData: {
155
+ a: 'foo',
156
+ },
157
+ initialData: {
158
+ a: '',
180
159
  },
160
+ submitting: false,
161
+ error: undefined,
181
162
  },
182
- }),
183
- );
184
- const options = {
185
- wait: false,
186
- silent: false,
187
- message: '',
188
- onSubmit,
189
- onChange: undefined,
190
- emptyData: {},
191
- };
192
- const { changed, formData, submit } = useForm({}, undefined as any, options, 'foo');
193
- const preventDefault = vitest.fn();
194
- (submit as any)({ preventDefault });
195
- expect(changed).toBeTruthy();
196
- expect(preventDefault).toBeCalled();
197
- expect(onSubmit).toHaveBeenCalledWith({
198
- a: 'foo',
199
- });
200
- expect(formData).toEqual({
201
- a: 'foo',
202
- });
203
- },
204
- testOptions,
205
- );
163
+ },
164
+ }),
165
+ );
166
+ const options = {
167
+ wait: false,
168
+ silent: false,
169
+ message: '',
170
+ onSubmit,
171
+ onChange: undefined,
172
+ emptyData: {},
173
+ };
174
+ const { changed, formData, submit } = useForm({}, undefined as any, options, 'foo');
175
+ const preventDefault = vitest.fn();
176
+ (submit as any)({ preventDefault });
177
+ expect(changed).toBeTruthy();
178
+ expect(preventDefault).toBeCalled();
179
+ expect(onSubmit).toHaveBeenCalledWith({
180
+ a: 'foo',
181
+ });
182
+ expect(formData).toEqual({
183
+ a: 'foo',
184
+ });
185
+ });
206
186
 
207
- it(
208
- 'Submit with changed data running into an error',
209
- async () => {
210
- const { useForm } = await import('./useForm');
211
- const onSubmit = vitest.fn(() => Promise.reject('My error'));
187
+ it('Submit with changed data running into an error', testOptions, async () => {
188
+ const { useForm } = await import('./useForm');
189
+ const onSubmit = vitest.fn(() => Promise.reject('My error'));
212
190
 
213
- useGlobalState.mockImplementation((select: any) =>
214
- select({
215
- forms: {
216
- foo: {
217
- changed: true,
218
- currentData: {
219
- a: 'foo',
220
- },
221
- initialData: {
222
- a: '',
223
- },
224
- submitting: false,
225
- error: undefined,
191
+ useGlobalState.mockImplementation((select: any) =>
192
+ select({
193
+ forms: {
194
+ foo: {
195
+ changed: true,
196
+ currentData: {
197
+ a: 'foo',
198
+ },
199
+ initialData: {
200
+ a: '',
226
201
  },
202
+ submitting: false,
203
+ error: undefined,
227
204
  },
228
- }),
229
- );
230
- const options = {
231
- wait: false,
232
- silent: false,
233
- message: '',
234
- onSubmit,
235
- onChange: undefined,
236
- emptyData: {},
237
- };
238
- const { changed, formData, submit } = useForm({}, undefined as any, options, 'foo');
239
- submit();
240
- expect(changed).toBeTruthy();
241
- expect(onSubmit).toHaveBeenCalledWith({
242
- a: 'foo',
243
- });
244
- expect(formData).toEqual({
245
- a: 'foo',
246
- });
247
- },
248
- testOptions,
249
- );
205
+ },
206
+ }),
207
+ );
208
+ const options = {
209
+ wait: false,
210
+ silent: false,
211
+ message: '',
212
+ onSubmit,
213
+ onChange: undefined,
214
+ emptyData: {},
215
+ };
216
+ const { changed, formData, submit } = useForm({}, undefined as any, options, 'foo');
217
+ submit();
218
+ expect(changed).toBeTruthy();
219
+ expect(onSubmit).toHaveBeenCalledWith({
220
+ a: 'foo',
221
+ });
222
+ expect(formData).toEqual({
223
+ a: 'foo',
224
+ });
225
+ });
250
226
 
251
- it(
252
- 'Sets new data on changeForm',
253
- async () => {
254
- const { useForm } = await import('./useForm');
227
+ it('Sets new data on changeForm', testOptions, async () => {
228
+ const { useForm } = await import('./useForm');
255
229
 
256
- useGlobalState.mockImplementation((select: any) =>
257
- select({
258
- forms: {},
259
- }),
260
- );
261
- const options = {
262
- wait: false,
263
- silent: false,
264
- message: '',
265
- onSubmit() {
266
- return Promise.resolve();
267
- },
268
- onChange: undefined,
269
- emptyData: {},
270
- };
271
- const { changeForm } = useForm({}, undefined as any, options, 'id');
272
- changeForm({
273
- target: {
274
- name: 'foo',
275
- value: 'bar',
276
- },
277
- } as any);
278
- expect(setStateFake).toHaveBeenCalledTimes(2);
279
- expect(setStateFake).toHaveBeenNthCalledWith(
280
- 2,
281
- 'id',
282
- {
283
- active: true,
284
- currentData: {},
285
- initialData: {},
286
- changed: false,
287
- submitting: false,
288
- error: undefined,
289
- },
290
- {
291
- currentData: {
292
- foo: 'bar',
293
- },
294
- changed: true,
295
- error: undefined,
230
+ useGlobalState.mockImplementation((select: any) =>
231
+ select({
232
+ forms: {},
233
+ }),
234
+ );
235
+ const options = {
236
+ wait: false,
237
+ silent: false,
238
+ message: '',
239
+ onSubmit() {
240
+ return Promise.resolve();
241
+ },
242
+ onChange: undefined,
243
+ emptyData: {},
244
+ };
245
+ const { changeForm } = useForm({}, undefined as any, options, 'id');
246
+ changeForm({
247
+ target: {
248
+ name: 'foo',
249
+ value: 'bar',
250
+ },
251
+ } as any);
252
+ expect(setStateFake).toHaveBeenCalledTimes(2);
253
+ expect(setStateFake).toHaveBeenNthCalledWith(
254
+ 2,
255
+ 'id',
256
+ {
257
+ active: true,
258
+ currentData: {},
259
+ initialData: {},
260
+ changed: false,
261
+ submitting: false,
262
+ error: undefined,
263
+ },
264
+ {
265
+ currentData: {
266
+ foo: 'bar',
296
267
  },
297
- );
298
- },
299
- testOptions,
300
- );
268
+ changed: true,
269
+ error: undefined,
270
+ },
271
+ );
272
+ });
301
273
 
302
- it(
303
- 'Sets new data on setFormData',
304
- async () => {
305
- const { useForm } = await import('./useForm');
274
+ it('Sets new data on setFormData', testOptions, async () => {
275
+ const { useForm } = await import('./useForm');
306
276
 
307
- useGlobalState.mockImplementation((select: any) =>
308
- select({
309
- forms: {},
310
- }),
311
- );
312
- const options = {
313
- wait: false,
314
- silent: false,
315
- message: '',
316
- onSubmit() {
317
- return Promise.resolve();
318
- },
319
- onChange: undefined,
320
- emptyData: {},
321
- };
322
- const { setFormData } = useForm({}, undefined as any, options, 'id');
323
- setFormData({
324
- foo: 'a',
325
- bar: 'b',
326
- } as any);
327
- expect(setStateFake).toHaveBeenCalledTimes(2);
328
- expect(setStateFake).toHaveBeenNthCalledWith(
329
- 2,
330
- 'id',
331
- {
332
- active: true,
333
- currentData: {},
334
- initialData: {},
335
- changed: false,
336
- submitting: false,
337
- error: undefined,
277
+ useGlobalState.mockImplementation((select: any) =>
278
+ select({
279
+ forms: {},
280
+ }),
281
+ );
282
+ const options = {
283
+ wait: false,
284
+ silent: false,
285
+ message: '',
286
+ onSubmit() {
287
+ return Promise.resolve();
288
+ },
289
+ onChange: undefined,
290
+ emptyData: {},
291
+ };
292
+ const { setFormData } = useForm({}, undefined as any, options, 'id');
293
+ setFormData({
294
+ foo: 'a',
295
+ bar: 'b',
296
+ } as any);
297
+ expect(setStateFake).toHaveBeenCalledTimes(2);
298
+ expect(setStateFake).toHaveBeenNthCalledWith(
299
+ 2,
300
+ 'id',
301
+ {
302
+ active: true,
303
+ currentData: {},
304
+ initialData: {},
305
+ changed: false,
306
+ submitting: false,
307
+ error: undefined,
308
+ },
309
+ {
310
+ currentData: {
311
+ foo: 'a',
312
+ bar: 'b',
338
313
  },
339
- {
340
- currentData: {
341
- foo: 'a',
342
- bar: 'b',
343
- },
344
- changed: true,
345
- error: undefined,
346
- },
347
- );
348
- },
349
- testOptions,
350
- );
314
+ changed: true,
315
+ error: undefined,
316
+ },
317
+ );
318
+ });
351
319
 
352
- it(
353
- 'Resets changes to initial data',
354
- async () => {
355
- const { useForm } = await import('./useForm');
320
+ it('Resets changes to initial data', testOptions, async () => {
321
+ const { useForm } = await import('./useForm');
356
322
 
357
- useGlobalState.mockImplementation((select: any) =>
358
- select({
359
- forms: {
360
- id: {
361
- active: true,
362
- changed: true,
363
- currentData: {
364
- a: 'foo',
365
- },
366
- initialData: {
367
- a: '',
368
- },
369
- submitting: false,
370
- error: undefined,
323
+ useGlobalState.mockImplementation((select: any) =>
324
+ select({
325
+ forms: {
326
+ id: {
327
+ active: true,
328
+ changed: true,
329
+ currentData: {
330
+ a: 'foo',
371
331
  },
332
+ initialData: {
333
+ a: '',
334
+ },
335
+ submitting: false,
336
+ error: undefined,
372
337
  },
373
- }),
374
- );
375
- const options = {
376
- wait: false,
377
- silent: false,
378
- message: '',
379
- onSubmit() {
380
- return Promise.resolve();
381
338
  },
382
- onChange: undefined,
383
- emptyData: {},
384
- };
385
- const { reset } = useForm({}, undefined as any, options, 'id');
386
- reset();
387
- expect(setStateFake).toHaveBeenCalledTimes(2);
388
- expect(setStateFake).toHaveBeenNthCalledWith(
389
- 2,
390
- 'id',
391
- {
392
- active: true,
393
- currentData: {
394
- a: 'foo',
395
- },
396
- initialData: {
397
- a: '',
398
- },
399
- changed: true,
400
- submitting: false,
401
- error: undefined,
339
+ }),
340
+ );
341
+ const options = {
342
+ wait: false,
343
+ silent: false,
344
+ message: '',
345
+ onSubmit() {
346
+ return Promise.resolve();
347
+ },
348
+ onChange: undefined,
349
+ emptyData: {},
350
+ };
351
+ const { reset } = useForm({}, undefined as any, options, 'id');
352
+ reset();
353
+ expect(setStateFake).toHaveBeenCalledTimes(2);
354
+ expect(setStateFake).toHaveBeenNthCalledWith(
355
+ 2,
356
+ 'id',
357
+ {
358
+ active: true,
359
+ currentData: {
360
+ a: 'foo',
402
361
  },
403
- {
404
- currentData: {
405
- a: '',
406
- },
407
- changed: false,
408
- error: undefined,
362
+ initialData: {
363
+ a: '',
409
364
  },
410
- );
411
- },
412
- testOptions,
413
- );
365
+ changed: true,
366
+ submitting: false,
367
+ error: undefined,
368
+ },
369
+ {
370
+ currentData: {
371
+ a: '',
372
+ },
373
+ changed: false,
374
+ error: undefined,
375
+ },
376
+ );
377
+ });
414
378
 
415
- it(
416
- 'onChange should be triggered with full data set',
417
- async () => {
418
- const { useForm } = await import('./useForm');
419
- const onChange = vitest.fn((data) => Promise.resolve(data));
379
+ it('onChange should be triggered with full data set', testOptions, async () => {
380
+ const { useForm } = await import('./useForm');
381
+ const onChange = vitest.fn((data) => Promise.resolve(data));
420
382
 
421
- useGlobalState.mockImplementation((select: any) =>
422
- select({
423
- forms: {
424
- id: {
425
- active: true,
426
- changed: true,
427
- currentData: {
428
- a: 'foo',
429
- },
430
- initialData: {
431
- a: '',
432
- },
433
- submitting: false,
434
- error: undefined,
383
+ useGlobalState.mockImplementation((select: any) =>
384
+ select({
385
+ forms: {
386
+ id: {
387
+ active: true,
388
+ changed: true,
389
+ currentData: {
390
+ a: 'foo',
391
+ },
392
+ initialData: {
393
+ a: '',
435
394
  },
395
+ submitting: false,
396
+ error: undefined,
436
397
  },
437
- }),
438
- );
439
- const options = {
440
- wait: false,
441
- silent: false,
442
- message: '',
443
- onChange,
444
- onSubmit() {
445
- return Promise.resolve();
446
398
  },
447
- emptyData: {},
448
- };
449
- const { setFormData } = useForm({}, undefined as any, options, 'id');
450
- setFormData({ a: 'b' });
451
- expect(onChange).toHaveBeenCalledWith({ a: 'b' });
452
- },
453
- testOptions,
454
- );
399
+ }),
400
+ );
401
+ const options = {
402
+ wait: false,
403
+ silent: false,
404
+ message: '',
405
+ onChange,
406
+ onSubmit() {
407
+ return Promise.resolve();
408
+ },
409
+ emptyData: {},
410
+ };
411
+ const { setFormData } = useForm({}, undefined as any, options, 'id');
412
+ setFormData({ a: 'b' });
413
+ expect(onChange).toHaveBeenCalledWith({ a: 'b' });
414
+ });
455
415
 
456
- it(
457
- 'onChange which fails should be handled gracefully',
458
- async () => {
459
- const { useForm } = await import('./useForm');
460
- const onChange = vitest.fn((data) => Promise.reject('my error'));
416
+ it('onChange which fails should be handled gracefully', testOptions, async () => {
417
+ const { useForm } = await import('./useForm');
418
+ const onChange = vitest.fn((data) => Promise.reject('my error'));
461
419
 
462
- useGlobalState.mockImplementation((select: any) =>
463
- select({
464
- forms: {},
465
- }),
466
- );
467
- const options = {
468
- wait: false,
469
- silent: false,
470
- message: '',
471
- onChange,
472
- onSubmit() {
473
- return Promise.resolve();
474
- },
475
- emptyData: {},
476
- };
477
- const { setFormData } = useForm({}, undefined as any, options);
478
- setFormData({ a: 'b' });
479
- expect(onChange).toHaveBeenCalledWith({ a: 'b' });
480
- },
481
- testOptions,
482
- );
420
+ useGlobalState.mockImplementation((select: any) =>
421
+ select({
422
+ forms: {},
423
+ }),
424
+ );
425
+ const options = {
426
+ wait: false,
427
+ silent: false,
428
+ message: '',
429
+ onChange,
430
+ onSubmit() {
431
+ return Promise.resolve();
432
+ },
433
+ emptyData: {},
434
+ };
435
+ const { setFormData } = useForm({}, undefined as any, options);
436
+ setFormData({ a: 'b' });
437
+ expect(onChange).toHaveBeenCalledWith({ a: 'b' });
438
+ });
483
439
 
484
- it(
485
- 'cleanup sets active to false',
486
- async () => {
487
- const { useForm } = await import('./useForm');
488
- (React as any).useEffect = vitest.fn((cb) => cb()());
440
+ it('cleanup sets active to false', testOptions, async () => {
441
+ const { useForm } = await import('./useForm');
442
+ (React as any).useEffect = vitest.fn((cb) => cb()());
489
443
 
490
- useGlobalState.mockImplementation((select: any) =>
491
- select({
492
- forms: {},
493
- }),
494
- );
495
- const options = {
496
- wait: false,
497
- silent: false,
498
- message: '',
499
- onChange: undefined,
500
- onSubmit() {
501
- return Promise.resolve();
502
- },
503
- emptyData: {},
504
- };
505
- useForm({}, undefined as any, options, 'id');
506
- expect(setStateFake).toHaveBeenCalledTimes(2);
507
- expect(setStateFake).toHaveBeenNthCalledWith(
508
- 2,
509
- 'id',
510
- {
511
- active: true,
512
- changed: false,
513
- currentData: {},
514
- error: undefined,
515
- initialData: {},
516
- submitting: false,
517
- },
518
- { active: false },
519
- );
520
- },
521
- testOptions,
522
- );
444
+ useGlobalState.mockImplementation((select: any) =>
445
+ select({
446
+ forms: {},
447
+ }),
448
+ );
449
+ const options = {
450
+ wait: false,
451
+ silent: false,
452
+ message: '',
453
+ onChange: undefined,
454
+ onSubmit() {
455
+ return Promise.resolve();
456
+ },
457
+ emptyData: {},
458
+ };
459
+ useForm({}, undefined as any, options, 'id');
460
+ expect(setStateFake).toHaveBeenCalledTimes(2);
461
+ expect(setStateFake).toHaveBeenNthCalledWith(
462
+ 2,
463
+ 'id',
464
+ {
465
+ active: true,
466
+ changed: false,
467
+ currentData: {},
468
+ error: undefined,
469
+ initialData: {},
470
+ submitting: false,
471
+ },
472
+ { active: false },
473
+ );
474
+ });
523
475
  });