@hyper-fetch/react 9.6.1 → 9.7.0

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 (98) hide show
  1. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  2. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  3. package/__tests__/features/helpers/utils.spec.ts +127 -0
  4. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  5. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  6. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  7. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  8. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  9. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  10. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  11. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  12. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  13. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  14. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  15. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  16. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  17. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  18. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  19. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  20. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  21. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  22. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  23. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  24. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  25. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  26. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  27. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  28. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  29. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  30. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  31. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  32. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  33. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  34. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  35. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  36. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  37. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  38. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  39. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  40. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  41. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  42. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  43. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  44. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  45. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  46. package/__tests__/features/use-submit/use-submit.optimistic-helpers.spec.tsx +455 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  48. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  49. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  50. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  51. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  52. package/__tests__/utils/gate.utils.ts +103 -0
  53. package/__tests__/utils/gated-client.utils.ts +158 -0
  54. package/__tests__/utils/helpers.utils.ts +19 -0
  55. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  57. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  60. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  61. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  69. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  70. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-submit/use-submit.constants.d.ts +1 -1
  73. package/dist/hooks/use-submit/use-submit.constants.d.ts.map +1 -1
  74. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  75. package/dist/hooks/use-submit/use-submit.types.d.ts +6 -1
  76. package/dist/hooks/use-submit/use-submit.types.d.ts.map +1 -1
  77. package/dist/index.mjs +633 -346
  78. package/dist/index.mjs.map +1 -1
  79. package/dist/provider/provider.d.ts.map +1 -1
  80. package/package.json +1 -1
  81. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  82. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  83. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  84. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  85. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  86. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  87. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  88. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  89. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  90. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  91. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  92. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  93. package/src/hooks/use-submit/use-submit.constants.ts +3 -1
  94. package/src/hooks/use-submit/use-submit.hooks.ts +167 -53
  95. package/src/hooks/use-submit/use-submit.types.ts +6 -0
  96. package/src/provider/provider.tsx +9 -1
  97. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  98. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,644 @@
1
+ import type { ExtractAdapterResolvedType, RequestInstance } from "@hyper-fetch/core";
2
+ import { act, renderHook } from "@testing-library/react";
3
+ import type { UseSubmitOptionsType } from "hooks/use-submit";
4
+ import { useSubmit } from "hooks/use-submit";
5
+ import { StrictMode } from "react";
6
+
7
+ import { createGatedClient } from "../../utils/gated-client.utils";
8
+
9
+ type User = { id: number; name: string };
10
+
11
+ const setup = () => {
12
+ const gated = createGatedClient();
13
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
14
+ endpoint: "/users",
15
+ method: "POST",
16
+ });
17
+ return { ...gated, request };
18
+ };
19
+
20
+ const debounce = { bounce: true, bounceType: "debounce", bounceTime: 400 } as const;
21
+ const throttle = { bounce: true, bounceType: "throttle", bounceTime: 400, bounceTimeout: 400 } as const;
22
+
23
+ /** The tests read the state outside of the render, so the hook has to rerender on every change */
24
+ const useUntrackedSubmit = <T extends RequestInstance>(request: T, options?: UseSubmitOptionsType<T>) =>
25
+ useSubmit(request, { dependencyTracking: false, ...options } as UseSubmitOptionsType<T>);
26
+
27
+ /** Run the pending timers and promise callbacks */
28
+ const advance = async (time = 0) => {
29
+ await act(async () => {
30
+ await vi.advanceTimersByTimeAsync(time);
31
+ });
32
+ };
33
+
34
+ /** Collects the responses of the submit calls in the order they got resolved */
35
+ const createCollector = <T extends RequestInstance>() => {
36
+ const responses: { label: string; response: ExtractAdapterResolvedType<T> }[] = [];
37
+ const collect = (label: string) => (response: ExtractAdapterResolvedType<T>) => {
38
+ responses.push({ label, response });
39
+ };
40
+ return { responses, collect };
41
+ };
42
+
43
+ describe("useSubmit [ Bounce ]", () => {
44
+ beforeEach(() => {
45
+ vi.useFakeTimers();
46
+ });
47
+
48
+ afterEach(() => {
49
+ vi.useRealTimers();
50
+ });
51
+
52
+ describe("given the bounce is off", () => {
53
+ it("should send every submit right away", async () => {
54
+ const { request, calls } = setup();
55
+ const { result } = renderHook(() => useUntrackedSubmit(request));
56
+
57
+ act(() => {
58
+ result.current.submit({ payload: { name: "First" } });
59
+ result.current.submit({ payload: { name: "Second" } });
60
+ });
61
+ await advance();
62
+
63
+ expect(calls).toHaveLength(2);
64
+ expect(result.current.bounce.active).toBeFalse();
65
+ });
66
+ });
67
+
68
+ describe("given the submits are debounced", () => {
69
+ it("should not send the request before the bounce time passes", async () => {
70
+ const { request, calls } = setup();
71
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
72
+
73
+ act(() => {
74
+ result.current.submit({ payload: { name: "Maciej" } });
75
+ });
76
+ await advance(399);
77
+
78
+ expect(calls).toHaveLength(0);
79
+ expect(result.current.submitting).toBeFalse();
80
+ });
81
+ it("should send the request once the bounce time passes", async () => {
82
+ const { request, calls } = setup();
83
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
84
+
85
+ act(() => {
86
+ result.current.submit({ payload: { name: "Maciej" } });
87
+ });
88
+ await advance(400);
89
+
90
+ expect(calls).toHaveLength(1);
91
+ expect(calls[0].request.payload).toStrictEqual({ name: "Maciej" });
92
+ expect(result.current.submitting).toBeTrue();
93
+ });
94
+ it("should use the default bounce time of 400ms", async () => {
95
+ const { request, calls } = setup();
96
+ const { result } = renderHook(() => useUntrackedSubmit(request, { bounce: true }));
97
+
98
+ act(() => {
99
+ result.current.submit({ payload: { name: "Maciej" } });
100
+ });
101
+ await advance(399);
102
+ expect(calls).toHaveLength(0);
103
+
104
+ await advance(1);
105
+ expect(calls).toHaveLength(1);
106
+ });
107
+ it("should send only the last of the submits made within the bounce time", async () => {
108
+ const { request, calls } = setup();
109
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
110
+
111
+ act(() => {
112
+ result.current.submit({ payload: { name: "First" } });
113
+ result.current.submit({ payload: { name: "Second" } });
114
+ result.current.submit({ payload: { name: "Third" } });
115
+ });
116
+ await advance(400);
117
+
118
+ expect(calls).toHaveLength(1);
119
+ expect(calls[0].request.payload).toStrictEqual({ name: "Third" });
120
+ });
121
+ it("should restart the bounce time with every submit", async () => {
122
+ const { request, calls } = setup();
123
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
124
+
125
+ for (let index = 0; index < 5; index += 1) {
126
+ act(() => {
127
+ result.current.submit({ payload: { name: `Call ${index}` } });
128
+ });
129
+ // eslint-disable-next-line no-await-in-loop
130
+ await advance(300);
131
+ }
132
+ expect(calls).toHaveLength(0);
133
+
134
+ await advance(100);
135
+ expect(calls).toHaveLength(1);
136
+ expect(calls[0].request.payload).toStrictEqual({ name: "Call 4" });
137
+ });
138
+ it("should resolve every submit of the batch with the response of the sent request", async () => {
139
+ const { request, calls } = setup();
140
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
141
+ const { responses, collect } = createCollector<typeof request>();
142
+
143
+ act(() => {
144
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
145
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
146
+ result.current.submit({ payload: { name: "Third" } }).then(collect("third"));
147
+ });
148
+ await advance(400);
149
+ expect(responses).toHaveLength(0);
150
+
151
+ calls[0].succeed({ id: 3, name: "Third" });
152
+ await advance();
153
+
154
+ expect(responses.map((item) => item.label)).toStrictEqual(["first", "second", "third"]);
155
+ expect(responses.map((item) => item.response.data)).toStrictEqual([
156
+ { id: 3, name: "Third" },
157
+ { id: 3, name: "Third" },
158
+ { id: 3, name: "Third" },
159
+ ]);
160
+ });
161
+ it("should resolve every submit of the batch with the error of the sent request", async () => {
162
+ const { request, calls } = setup();
163
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
164
+ const { responses, collect } = createCollector<typeof request>();
165
+
166
+ act(() => {
167
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
168
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
169
+ });
170
+ await advance(400);
171
+ calls[0].fail({ message: "Nope" }, 400);
172
+ await advance();
173
+
174
+ expect(responses.map((item) => item.response.error)).toStrictEqual([{ message: "Nope" }, { message: "Nope" }]);
175
+ expect(responses.map((item) => item.response.success)).toStrictEqual([false, false]);
176
+ });
177
+ it("should send a new request for the submits made after the bounce time", async () => {
178
+ const { request, calls } = setup();
179
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
180
+ const { responses, collect } = createCollector<typeof request>();
181
+
182
+ act(() => {
183
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
184
+ });
185
+ await advance(400);
186
+ act(() => {
187
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
188
+ });
189
+ await advance(400);
190
+ expect(calls).toHaveLength(2);
191
+
192
+ calls[0].succeed({ id: 1, name: "First" });
193
+ calls[1].succeed({ id: 2, name: "Second" });
194
+ await advance();
195
+
196
+ expect(responses.map((item) => [item.label, item.response.data?.name])).toStrictEqual([
197
+ ["first", "First"],
198
+ ["second", "Second"],
199
+ ]);
200
+ });
201
+ it("should report the active bounce until the request is sent", async () => {
202
+ const { request } = setup();
203
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
204
+ expect(result.current.bounce.active).toBeFalse();
205
+
206
+ act(() => {
207
+ result.current.submit({ payload: { name: "Maciej" } });
208
+ });
209
+ expect(result.current.bounce.active).toBeTrue();
210
+
211
+ await advance(400);
212
+ expect(result.current.bounce.active).toBeFalse();
213
+ });
214
+ it("should call the callbacks once for the batch", async () => {
215
+ const { request, calls } = setup();
216
+ const success = vi.fn();
217
+ const requestStart = vi.fn();
218
+ const { result } = renderHook(() => {
219
+ const view = useUntrackedSubmit(request, debounce);
220
+ view.onSubmitSuccess(success);
221
+ view.onSubmitRequestStart(requestStart);
222
+ return view;
223
+ });
224
+
225
+ act(() => {
226
+ result.current.submit({ payload: { name: "First" } });
227
+ result.current.submit({ payload: { name: "Second" } });
228
+ });
229
+ await advance(400);
230
+ calls[0].succeed({ id: 2, name: "Second" });
231
+ await advance();
232
+
233
+ expect(requestStart).toHaveBeenCalledTimes(1);
234
+ expect(success).toHaveBeenCalledTimes(1);
235
+ });
236
+ it("should run the optimistic callback once, when the request is sent", async () => {
237
+ const { request, calls } = setup();
238
+ const optimistic = vi.fn(() => ({ context: { applied: true } }));
239
+ const { result } = renderHook(() => useUntrackedSubmit(request.setOptimistic(optimistic), debounce));
240
+
241
+ act(() => {
242
+ result.current.submit({ payload: { name: "First" } });
243
+ result.current.submit({ payload: { name: "Second" } });
244
+ });
245
+ await advance(399);
246
+ expect(optimistic).not.toHaveBeenCalled();
247
+
248
+ await advance(1);
249
+ expect(optimistic).toHaveBeenCalledTimes(1);
250
+ expect(calls).toHaveLength(1);
251
+ });
252
+ it("should follow the bounce time changed on rerender", async () => {
253
+ const { request, calls } = setup();
254
+ const { result, rerender } = renderHook(
255
+ ({ bounceTime }: { bounceTime: number }) => useUntrackedSubmit(request, { bounce: true, bounceTime }),
256
+ { initialProps: { bounceTime: 400 } },
257
+ );
258
+
259
+ rerender({ bounceTime: 1000 });
260
+ act(() => {
261
+ result.current.submit({ payload: { name: "Maciej" } });
262
+ });
263
+ await advance(999);
264
+ expect(calls).toHaveLength(0);
265
+
266
+ await advance(1);
267
+ expect(calls).toHaveLength(1);
268
+ });
269
+ it("should not start the bounce when the hook is disabled", async () => {
270
+ const { request, calls } = setup();
271
+ const { result } = renderHook(() => useUntrackedSubmit(request, { ...debounce, disabled: true }));
272
+ const { responses, collect } = createCollector<typeof request>();
273
+
274
+ act(() => {
275
+ result.current.submit({ payload: { name: "Maciej" } }).then(collect("disabled"));
276
+ });
277
+ await advance(400);
278
+
279
+ expect(calls).toHaveLength(0);
280
+ expect(responses).toHaveLength(1);
281
+ expect(responses[0].response.success).toBeFalse();
282
+ expect(result.current.bounce.active).toBeFalse();
283
+ });
284
+ it("should work in StrictMode", async () => {
285
+ const { request, calls } = setup();
286
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce), { wrapper: StrictMode });
287
+ const { responses, collect } = createCollector<typeof request>();
288
+
289
+ act(() => {
290
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
291
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
292
+ });
293
+ await advance(400);
294
+ expect(calls).toHaveLength(1);
295
+ calls[0].succeed({ id: 2, name: "Second" });
296
+ await advance();
297
+
298
+ expect(responses.map((item) => item.response.data?.name)).toStrictEqual(["Second", "Second"]);
299
+ });
300
+ });
301
+
302
+ describe("given the debounced submit gets reset", () => {
303
+ it("should not send the request", async () => {
304
+ const { request, calls } = setup();
305
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
306
+ act(() => {
307
+ result.current.submit({ payload: { name: "Maciej" } });
308
+ });
309
+
310
+ act(() => {
311
+ result.current.bounce.reset();
312
+ });
313
+ await advance(1000);
314
+
315
+ expect(calls).toHaveLength(0);
316
+ });
317
+ it("should resolve the waiting submits with an error response", async () => {
318
+ const { request } = setup();
319
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
320
+ const { responses, collect } = createCollector<typeof request>();
321
+ act(() => {
322
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
323
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
324
+ });
325
+
326
+ act(() => {
327
+ result.current.bounce.reset();
328
+ });
329
+ await advance();
330
+
331
+ expect(responses.map((item) => item.label)).toStrictEqual(["first", "second"]);
332
+ expect(responses[0].response).toStrictEqual({
333
+ data: null,
334
+ error: expect.any(Error),
335
+ status: null,
336
+ success: false,
337
+ extra: request.client.adapter.defaultExtra,
338
+ requestTimestamp: expect.toBeNumber(),
339
+ responseTimestamp: expect.toBeNumber(),
340
+ });
341
+ });
342
+ it("should report the bounce as not active anymore", async () => {
343
+ const { request } = setup();
344
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
345
+ act(() => {
346
+ result.current.submit({ payload: { name: "Maciej" } });
347
+ });
348
+ expect(result.current.bounce.active).toBeTrue();
349
+
350
+ act(() => {
351
+ result.current.bounce.reset();
352
+ });
353
+
354
+ expect(result.current.bounce.active).toBeFalse();
355
+ });
356
+ it("should send the submits made after the reset", async () => {
357
+ const { request, calls } = setup();
358
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
359
+ const { responses, collect } = createCollector<typeof request>();
360
+ act(() => {
361
+ result.current.submit({ payload: { name: "First" } });
362
+ });
363
+ act(() => {
364
+ result.current.bounce.reset();
365
+ });
366
+
367
+ act(() => {
368
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
369
+ });
370
+ await advance(400);
371
+ calls[0].succeed({ id: 2, name: "Second" });
372
+ await advance();
373
+
374
+ expect(calls).toHaveLength(1);
375
+ expect(calls[0].request.payload).toStrictEqual({ name: "Second" });
376
+ expect(responses[0].response.data).toStrictEqual({ id: 2, name: "Second" });
377
+ });
378
+ it("should do nothing when there is no submit waiting", async () => {
379
+ const { request, calls } = setup();
380
+ const { result } = renderHook(() => useUntrackedSubmit(request, debounce));
381
+
382
+ act(() => {
383
+ result.current.bounce.reset();
384
+ });
385
+ await advance(1000);
386
+
387
+ expect(calls).toHaveLength(0);
388
+ expect(result.current.bounce.active).toBeFalse();
389
+ });
390
+ });
391
+
392
+ describe("given the hook unmounts during the bounce time", () => {
393
+ it("should not send the debounced request", async () => {
394
+ const { request, calls } = setup();
395
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request, debounce));
396
+ act(() => {
397
+ result.current.submit({ payload: { name: "Maciej" } });
398
+ });
399
+
400
+ unmount();
401
+ await advance(1000);
402
+
403
+ expect(calls).toHaveLength(0);
404
+ expect(vi.getTimerCount()).toBe(0);
405
+ });
406
+ it("should resolve the waiting debounced submits with an error response", async () => {
407
+ const { request } = setup();
408
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request, debounce));
409
+ const { responses, collect } = createCollector<typeof request>();
410
+ act(() => {
411
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
412
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
413
+ });
414
+
415
+ unmount();
416
+ await advance();
417
+
418
+ expect(responses.map((item) => item.label)).toStrictEqual(["first", "second"]);
419
+ expect(responses.map((item) => item.response.success)).toStrictEqual([false, false]);
420
+ expect(responses[0].response.error).toBeInstanceOf(Error);
421
+ expect(responses[0].response.data).toBeNull();
422
+ });
423
+ it("should not send the trailing throttled request", async () => {
424
+ const { request, calls } = setup();
425
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request, throttle));
426
+ act(() => {
427
+ result.current.submit({ payload: { name: "First" } });
428
+ result.current.submit({ payload: { name: "Second" } });
429
+ });
430
+ await advance();
431
+ expect(calls).toHaveLength(1);
432
+
433
+ unmount();
434
+ await advance(1000);
435
+
436
+ expect(calls).toHaveLength(1);
437
+ expect(vi.getTimerCount()).toBe(0);
438
+ });
439
+ it("should resolve the waiting throttled submits with an error response", async () => {
440
+ const { request } = setup();
441
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request, throttle));
442
+ const { responses, collect } = createCollector<typeof request>();
443
+ act(() => {
444
+ result.current.submit({ payload: { name: "First" } });
445
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
446
+ });
447
+
448
+ unmount();
449
+ await advance();
450
+
451
+ expect(responses.map((item) => item.label)).toStrictEqual(["second"]);
452
+ expect(responses[0].response.success).toBeFalse();
453
+ });
454
+ it("should keep the already sent request running", async () => {
455
+ const { request, calls } = setup();
456
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request, debounce));
457
+ const { responses, collect } = createCollector<typeof request>();
458
+ act(() => {
459
+ result.current.submit({ payload: { name: "Maciej" } }).then(collect("sent"));
460
+ });
461
+ await advance(400);
462
+
463
+ unmount();
464
+ calls[0].succeed({ id: 1, name: "Maciej" });
465
+ await advance();
466
+
467
+ expect(calls[0].aborted).toBeFalse();
468
+ expect(responses[0].response.data).toStrictEqual({ id: 1, name: "Maciej" });
469
+ });
470
+ });
471
+
472
+ describe("given the submits are throttled", () => {
473
+ it("should send the first submit right away", async () => {
474
+ const { request, calls } = setup();
475
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
476
+
477
+ act(() => {
478
+ result.current.submit({ payload: { name: "First" } });
479
+ });
480
+ await advance();
481
+
482
+ expect(calls).toHaveLength(1);
483
+ expect(calls[0].request.payload).toStrictEqual({ name: "First" });
484
+ });
485
+ it("should hold the submits made within the interval", async () => {
486
+ const { request, calls } = setup();
487
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
488
+
489
+ act(() => {
490
+ result.current.submit({ payload: { name: "First" } });
491
+ result.current.submit({ payload: { name: "Second" } });
492
+ result.current.submit({ payload: { name: "Third" } });
493
+ });
494
+ await advance(399);
495
+
496
+ expect(calls).toHaveLength(1);
497
+ });
498
+ it("should send the last held submit after the timeout", async () => {
499
+ const { request, calls } = setup();
500
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
501
+
502
+ act(() => {
503
+ result.current.submit({ payload: { name: "First" } });
504
+ result.current.submit({ payload: { name: "Second" } });
505
+ result.current.submit({ payload: { name: "Third" } });
506
+ });
507
+ await advance(400);
508
+
509
+ expect(calls).toHaveLength(2);
510
+ expect(calls[1].request.payload).toStrictEqual({ name: "Third" });
511
+ });
512
+ it("should resolve the first submit with its own response and the held ones with the trailing response", async () => {
513
+ const { request, calls } = setup();
514
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
515
+ const { responses, collect } = createCollector<typeof request>();
516
+
517
+ act(() => {
518
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
519
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
520
+ result.current.submit({ payload: { name: "Third" } }).then(collect("third"));
521
+ });
522
+ await advance(400);
523
+ calls[0].succeed({ id: 1, name: "First" });
524
+ await advance();
525
+ calls[1].succeed({ id: 3, name: "Third" });
526
+ await advance();
527
+
528
+ expect(responses.map((item) => [item.label, item.response.data?.name])).toStrictEqual([
529
+ ["first", "First"],
530
+ ["second", "Third"],
531
+ ["third", "Third"],
532
+ ]);
533
+ });
534
+ it("should send a submit right away again once the interval passed", async () => {
535
+ const { request, calls } = setup();
536
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
537
+ act(() => {
538
+ result.current.submit({ payload: { name: "First" } });
539
+ });
540
+ await advance(400);
541
+
542
+ act(() => {
543
+ result.current.submit({ payload: { name: "Second" } });
544
+ });
545
+ await advance();
546
+
547
+ expect(calls).toHaveLength(2);
548
+ expect(calls[1].request.payload).toStrictEqual({ name: "Second" });
549
+ });
550
+ it("should report the active bounce while a submit is held", async () => {
551
+ const { request } = setup();
552
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
553
+
554
+ act(() => {
555
+ result.current.submit({ payload: { name: "First" } });
556
+ });
557
+ expect(result.current.bounce.active).toBeFalse();
558
+
559
+ act(() => {
560
+ result.current.submit({ payload: { name: "Second" } });
561
+ });
562
+ expect(result.current.bounce.active).toBeTrue();
563
+
564
+ await advance(400);
565
+ expect(result.current.bounce.active).toBeFalse();
566
+ });
567
+ it("should drop the held submit on reset and resolve it with an error response", async () => {
568
+ const { request, calls } = setup();
569
+ const { result } = renderHook(() => useUntrackedSubmit(request, throttle));
570
+ const { responses, collect } = createCollector<typeof request>();
571
+ act(() => {
572
+ result.current.submit({ payload: { name: "First" } });
573
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
574
+ });
575
+
576
+ act(() => {
577
+ result.current.bounce.reset();
578
+ });
579
+ await advance(1000);
580
+
581
+ expect(calls).toHaveLength(1);
582
+ expect(responses).toHaveLength(1);
583
+ expect(responses[0].response.success).toBeFalse();
584
+ expect(responses[0].response.error).toBeInstanceOf(Error);
585
+ expect(result.current.bounce.active).toBeFalse();
586
+ });
587
+ });
588
+
589
+ describe("given the throttle has no trailing timeout", () => {
590
+ const leadingOnly = { ...throttle, bounceTimeout: 0 } as const;
591
+
592
+ it("should send only the first submit of the interval", async () => {
593
+ const { request, calls } = setup();
594
+ const { result } = renderHook(() => useUntrackedSubmit(request, leadingOnly));
595
+
596
+ act(() => {
597
+ result.current.submit({ payload: { name: "First" } });
598
+ result.current.submit({ payload: { name: "Second" } });
599
+ });
600
+ await advance(1000);
601
+
602
+ expect(calls).toHaveLength(1);
603
+ expect(calls[0].request.payload).toStrictEqual({ name: "First" });
604
+ });
605
+ it("should resolve the dropped submits with an error response", async () => {
606
+ const { request, calls } = setup();
607
+ const { result } = renderHook(() => useUntrackedSubmit(request, leadingOnly));
608
+ const { responses, collect } = createCollector<typeof request>();
609
+
610
+ act(() => {
611
+ result.current.submit({ payload: { name: "First" } }).then(collect("first"));
612
+ result.current.submit({ payload: { name: "Second" } }).then(collect("second"));
613
+ result.current.submit({ payload: { name: "Third" } }).then(collect("third"));
614
+ });
615
+ await advance();
616
+
617
+ expect(responses.map((item) => item.label)).toStrictEqual(["second", "third"]);
618
+ expect(responses.map((item) => item.response.success)).toStrictEqual([false, false]);
619
+ expect(responses[0].response.error).toBeInstanceOf(Error);
620
+
621
+ calls[0].succeed({ id: 1, name: "First" });
622
+ await advance();
623
+
624
+ expect(responses[2].label).toBe("first");
625
+ expect(responses[2].response.data).toStrictEqual({ id: 1, name: "First" });
626
+ });
627
+ it("should send a submit again once the interval passed", async () => {
628
+ const { request, calls } = setup();
629
+ const { result } = renderHook(() => useUntrackedSubmit(request, leadingOnly));
630
+ act(() => {
631
+ result.current.submit({ payload: { name: "First" } });
632
+ result.current.submit({ payload: { name: "Dropped" } });
633
+ });
634
+ await advance(400);
635
+
636
+ act(() => {
637
+ result.current.submit({ payload: { name: "Second" } });
638
+ });
639
+ await advance();
640
+
641
+ expect(calls.map((call) => call.request.payload)).toStrictEqual([{ name: "First" }, { name: "Second" }]);
642
+ });
643
+ });
644
+ });