@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,552 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { getErrorMessage } from "@hyper-fetch/core";
3
+ import { act, renderHook, waitFor } from "@testing-library/react";
4
+ import { useSubmit } from "hooks/use-submit";
5
+
6
+ import { createGatedClient } from "../../utils/gated-client.utils";
7
+
8
+ type User = { id: number; name: string };
9
+
10
+ const setup = (options?: { queued?: boolean; cancelable?: boolean; deduplicate?: boolean }) => {
11
+ const gated = createGatedClient();
12
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
13
+ endpoint: "/users",
14
+ method: "POST",
15
+ queued: options?.queued ?? false,
16
+ cancelable: options?.cancelable ?? false,
17
+ deduplicate: options?.deduplicate ?? false,
18
+ });
19
+ /** Listeners attached to the request manager - they have to be gone once the requests are done */
20
+ const countListeners = () => {
21
+ const { emitter } = gated.client.requestManager;
22
+ return emitter.eventNames().reduce((sum, name) => sum + emitter.listenerCount(name), 0);
23
+ };
24
+ return { ...gated, request, countListeners };
25
+ };
26
+
27
+ /** Renders the hook and records every distinct `submitting` value it went through */
28
+ const renderSubmit = <T extends RequestInstance>(request: T) => {
29
+ const submittingHistory: boolean[] = [];
30
+ const spies = { success: vi.fn(), error: vi.fn(), abort: vi.fn(), finished: vi.fn() };
31
+ const view = renderHook(() => {
32
+ const submit = useSubmit(request, { dependencyTracking: false });
33
+ submit.onSubmitSuccess(spies.success);
34
+ submit.onSubmitError(spies.error);
35
+ submit.onSubmitAbort(spies.abort);
36
+ submit.onSubmitFinished(spies.finished);
37
+ if (submittingHistory.at(-1) !== submit.submitting) {
38
+ submittingHistory.push(submit.submitting);
39
+ }
40
+ return submit;
41
+ });
42
+ return { ...view, submittingHistory, spies };
43
+ };
44
+
45
+ describe("useSubmit [ Double submit ]", () => {
46
+ describe("given the request is sent all at once", () => {
47
+ it("should send both requests right away", async () => {
48
+ const { request, waitForCalls } = setup();
49
+ const { result } = renderSubmit(request);
50
+
51
+ act(() => {
52
+ result.current.submit({ payload: { name: "First" } });
53
+ result.current.submit({ payload: { name: "Second" } });
54
+ });
55
+
56
+ const calls = await waitForCalls(2);
57
+ expect(calls.map((call) => call.settled)).toStrictEqual([false, false]);
58
+ });
59
+ it("should stay submitting until the last request finishes", async () => {
60
+ const { request, waitForCalls } = setup();
61
+ const { result, submittingHistory } = renderSubmit(request);
62
+ let promises: Promise<unknown>[] = [];
63
+ act(() => {
64
+ promises = ["First", "Second", "Third"].map((name) => result.current.submit({ payload: { name } }));
65
+ });
66
+ const calls = await waitForCalls(3);
67
+
68
+ await act(async () => {
69
+ calls[0].succeed({ id: 1, name: "First" });
70
+ await promises[0];
71
+ });
72
+ expect(result.current.submitting).toBeTrue();
73
+
74
+ await act(async () => {
75
+ calls[1].fail({ message: "Nope" }, 400);
76
+ await promises[1];
77
+ });
78
+ expect(result.current.submitting).toBeTrue();
79
+
80
+ await act(async () => {
81
+ calls[2].succeed({ id: 3, name: "Third" });
82
+ await promises[2];
83
+ });
84
+ await waitFor(() => {
85
+ expect(result.current.submitting).toBeFalse();
86
+ });
87
+ expect(submittingHistory).toStrictEqual([false, true, false]);
88
+ });
89
+ it("should show the response that came last when they arrive in the order of the submits", async () => {
90
+ const { request, waitForCalls } = setup();
91
+ const { result } = renderSubmit(request);
92
+ let promises: Promise<unknown>[] = [];
93
+ act(() => {
94
+ promises = ["First", "Second"].map((name) => result.current.submit({ payload: { name } }));
95
+ });
96
+ const calls = await waitForCalls(2);
97
+
98
+ await act(async () => {
99
+ calls[0].succeed({ id: 1, name: "First" });
100
+ await promises[0];
101
+ });
102
+ await waitFor(() => {
103
+ expect(result.current.data).toStrictEqual({ id: 1, name: "First" });
104
+ });
105
+ await act(async () => {
106
+ calls[1].succeed({ id: 2, name: "Second" });
107
+ await promises[1];
108
+ });
109
+
110
+ await waitFor(() => {
111
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
112
+ });
113
+ });
114
+ it("should call the callbacks for both requests", async () => {
115
+ const { request, waitForCalls } = setup();
116
+ const { result, spies } = renderSubmit(request);
117
+ let promises: Promise<unknown>[] = [];
118
+ act(() => {
119
+ promises = ["First", "Second"].map((name) => result.current.submit({ payload: { name } }));
120
+ });
121
+ const calls = await waitForCalls(2);
122
+
123
+ await act(async () => {
124
+ calls[0].succeed({ id: 1, name: "First" });
125
+ calls[1].fail({ message: "Nope" }, 400);
126
+ await Promise.all(promises);
127
+ });
128
+
129
+ expect(spies.success).toHaveBeenCalledTimes(1);
130
+ expect(spies.error).toHaveBeenCalledTimes(1);
131
+ expect(spies.finished).toHaveBeenCalledTimes(2);
132
+ });
133
+ it("should release the listeners of the finished requests", async () => {
134
+ const { request, waitForCalls, countListeners } = setup();
135
+ const { result } = renderSubmit(request);
136
+ const idleListeners = countListeners();
137
+ let promises: Promise<unknown>[] = [];
138
+ act(() => {
139
+ promises = ["First", "Second", "Third"].map((name) => result.current.submit({ payload: { name } }));
140
+ });
141
+ const calls = await waitForCalls(3);
142
+ expect(countListeners()).toBeGreaterThan(idleListeners);
143
+
144
+ await act(async () => {
145
+ calls.forEach((call, index) => call.succeed({ id: index, name: "User" }));
146
+ await Promise.all(promises);
147
+ });
148
+
149
+ await waitFor(() => {
150
+ expect(countListeners()).toBe(idleListeners);
151
+ });
152
+ });
153
+ });
154
+
155
+ describe("given the request is queued", () => {
156
+ it("should send one request at a time", async () => {
157
+ const { request, waitForCall, calls } = setup({ queued: true });
158
+ const { result } = renderSubmit(request);
159
+
160
+ act(() => {
161
+ result.current.submit({ payload: { name: "First" } });
162
+ result.current.submit({ payload: { name: "Second" } });
163
+ result.current.submit({ payload: { name: "Third" } });
164
+ });
165
+ await waitForCall(0);
166
+
167
+ expect(calls).toHaveLength(1);
168
+ expect(calls[0].request.payload).toStrictEqual({ name: "First" });
169
+ });
170
+ it("should send the requests in the order of the submits", async () => {
171
+ const { request, waitForCall } = setup({ queued: true });
172
+ const { result } = renderSubmit(request);
173
+ const sent: unknown[] = [];
174
+ act(() => {
175
+ result.current.submit({ payload: { name: "First" } });
176
+ result.current.submit({ payload: { name: "Second" } });
177
+ result.current.submit({ payload: { name: "Third" } });
178
+ });
179
+
180
+ for (let index = 0; index < 3; index += 1) {
181
+ // eslint-disable-next-line no-await-in-loop
182
+ const call = await waitForCall(index);
183
+ sent.push(call.request.payload);
184
+ act(() => {
185
+ call.succeed({ id: index, name: "User" });
186
+ });
187
+ }
188
+
189
+ expect(sent).toStrictEqual([{ name: "First" }, { name: "Second" }, { name: "Third" }]);
190
+ });
191
+ it("should resolve the promises in the order of the submits", async () => {
192
+ const { request, waitForCall } = setup({ queued: true });
193
+ const { result } = renderSubmit(request);
194
+ const resolved: string[] = [];
195
+ let promises: Promise<unknown>[] = [];
196
+ act(() => {
197
+ promises = ["First", "Second", "Third"].map((name) =>
198
+ result.current.submit({ payload: { name } }).then((response) => resolved.push(response.data?.name ?? "")),
199
+ );
200
+ });
201
+
202
+ const answer = async (index: number) => {
203
+ const call = await waitForCall(index);
204
+ await act(async () => {
205
+ call.succeed({ id: index, name: (call.request.payload as { name: string }).name });
206
+ await promises[index];
207
+ });
208
+ };
209
+ await answer(0);
210
+ await answer(1);
211
+ await answer(2);
212
+
213
+ expect(resolved).toStrictEqual(["First", "Second", "Third"]);
214
+ });
215
+ it("should show the response of every request as it finishes", async () => {
216
+ const { request, waitForCall } = setup({ queued: true });
217
+ const { result } = renderSubmit(request);
218
+ act(() => {
219
+ result.current.submit({ payload: { name: "First" } });
220
+ result.current.submit({ payload: { name: "Second" } });
221
+ });
222
+
223
+ const firstCall = await waitForCall(0);
224
+ act(() => {
225
+ firstCall.succeed({ id: 1, name: "First" });
226
+ });
227
+ await waitFor(() => {
228
+ expect(result.current.data).toStrictEqual({ id: 1, name: "First" });
229
+ });
230
+
231
+ const secondCall = await waitForCall(1);
232
+ act(() => {
233
+ secondCall.succeed({ id: 2, name: "Second" });
234
+ });
235
+ await waitFor(() => {
236
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
237
+ });
238
+ });
239
+ it("should stop submitting after the last request", async () => {
240
+ const { request, waitForCall } = setup({ queued: true });
241
+ const { result } = renderSubmit(request);
242
+ let promises: Promise<unknown>[] = [];
243
+ act(() => {
244
+ promises = ["First", "Second"].map((name) => result.current.submit({ payload: { name } }));
245
+ });
246
+
247
+ const firstCall = await waitForCall(0);
248
+ act(() => {
249
+ firstCall.succeed({ id: 1, name: "First" });
250
+ });
251
+ const secondCall = await waitForCall(1);
252
+ expect(result.current.submitting).toBeTrue();
253
+ await act(async () => {
254
+ secondCall.succeed({ id: 2, name: "Second" });
255
+ await Promise.all(promises);
256
+ });
257
+
258
+ await waitFor(() => {
259
+ expect(result.current.submitting).toBeFalse();
260
+ });
261
+ });
262
+ it("should send the next request after a failed one", async () => {
263
+ const { request, waitForCall } = setup({ queued: true });
264
+ const { result, spies } = renderSubmit(request);
265
+ let promises: Promise<unknown>[] = [];
266
+ act(() => {
267
+ promises = ["First", "Second"].map((name) => result.current.submit({ payload: { name } }));
268
+ });
269
+
270
+ const firstCall = await waitForCall(0);
271
+ act(() => {
272
+ firstCall.fail({ message: "Nope" }, 400);
273
+ });
274
+ const secondCall = await waitForCall(1);
275
+ await act(async () => {
276
+ secondCall.succeed({ id: 2, name: "Second" });
277
+ await Promise.all(promises);
278
+ });
279
+
280
+ expect(spies.error).toHaveBeenCalledTimes(1);
281
+ expect(spies.success).toHaveBeenCalledTimes(1);
282
+ await waitFor(() => {
283
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
284
+ });
285
+ expect(result.current.error).toBeNull();
286
+ });
287
+ it("should send the next request after an aborted one", async () => {
288
+ const { request, waitForCall } = setup({ queued: true });
289
+ const { result } = renderSubmit(request);
290
+ act(() => {
291
+ result.current.submit({ payload: { name: "First" } });
292
+ result.current.submit({ payload: { name: "Second" } });
293
+ });
294
+ const firstCall = await waitForCall(0);
295
+
296
+ act(() => {
297
+ result.current.abort();
298
+ });
299
+
300
+ expect(firstCall.aborted).toBeTrue();
301
+ const secondCall = await waitForCall(1);
302
+ expect(secondCall.request.payload).toStrictEqual({ name: "Second" });
303
+ });
304
+ });
305
+
306
+ describe("given the request is cancelable", () => {
307
+ it("should cancel the previous request when the next submit comes", async () => {
308
+ const { request, waitForCall } = setup({ cancelable: true });
309
+ const { result } = renderSubmit(request);
310
+ act(() => {
311
+ result.current.submit({ payload: { name: "First" } });
312
+ });
313
+ const firstCall = await waitForCall(0);
314
+
315
+ act(() => {
316
+ result.current.submit({ payload: { name: "Second" } });
317
+ });
318
+
319
+ expect(firstCall.aborted).toBeTrue();
320
+ const secondCall = await waitForCall(1);
321
+ expect(secondCall.aborted).toBeFalse();
322
+ });
323
+ it("should resolve the canceled submit with the abort error and the next one with the data", async () => {
324
+ const { request, waitForCall } = setup({ cancelable: true });
325
+ const { result } = renderSubmit(request);
326
+ let first: ReturnType<typeof result.current.submit> | null = null;
327
+ let second: ReturnType<typeof result.current.submit> | null = null;
328
+ act(() => {
329
+ first = result.current.submit({ payload: { name: "First" } });
330
+ });
331
+ await waitForCall(0);
332
+ act(() => {
333
+ second = result.current.submit({ payload: { name: "Second" } });
334
+ });
335
+ const secondCall = await waitForCall(1);
336
+ act(() => {
337
+ secondCall.succeed({ id: 2, name: "Second" });
338
+ });
339
+
340
+ const [firstResponse, secondResponse] = await Promise.all([first!, second!]);
341
+ expect(firstResponse.error).toStrictEqual(getErrorMessage("abort"));
342
+ expect(firstResponse.success).toBeFalse();
343
+ expect(secondResponse.data).toStrictEqual({ id: 2, name: "Second" });
344
+ });
345
+ it("should end with the state of the latest submit", async () => {
346
+ const { request, waitForCall } = setup({ cancelable: true });
347
+ const { result } = renderSubmit(request);
348
+ let promise: Promise<unknown> = Promise.resolve();
349
+ act(() => {
350
+ result.current.submit({ payload: { name: "First" } });
351
+ });
352
+ await waitForCall(0);
353
+ act(() => {
354
+ promise = result.current.submit({ payload: { name: "Second" } });
355
+ });
356
+ const secondCall = await waitForCall(1);
357
+
358
+ await act(async () => {
359
+ secondCall.succeed({ id: 2, name: "Second" });
360
+ await promise;
361
+ });
362
+
363
+ await waitFor(() => {
364
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
365
+ });
366
+ expect(result.current.error).toBeNull();
367
+ expect(result.current.success).toBeTrue();
368
+ expect(result.current.submitting).toBeFalse();
369
+ });
370
+ it("should stay submitting while the previous request gets replaced", async () => {
371
+ const { request, waitForCall } = setup({ cancelable: true });
372
+ const { result, submittingHistory } = renderSubmit(request);
373
+ let promise: Promise<unknown> = Promise.resolve();
374
+ act(() => {
375
+ result.current.submit({ payload: { name: "First" } });
376
+ });
377
+ await waitForCall(0);
378
+ act(() => {
379
+ promise = result.current.submit({ payload: { name: "Second" } });
380
+ });
381
+ const secondCall = await waitForCall(1);
382
+ await act(async () => {
383
+ secondCall.succeed({ id: 2, name: "Second" });
384
+ await promise;
385
+ });
386
+ await waitFor(() => {
387
+ expect(result.current.submitting).toBeFalse();
388
+ });
389
+
390
+ expect(submittingHistory).toStrictEqual([false, true, false]);
391
+ });
392
+ it("should let only the last of many quick submits through", async () => {
393
+ const { request, waitForCall, calls } = setup({ cancelable: true });
394
+ const { result, spies } = renderSubmit(request);
395
+ let promises: Promise<unknown>[] = [];
396
+ act(() => {
397
+ result.current.submit({ payload: { name: "First" } });
398
+ });
399
+ await waitForCall(0);
400
+ act(() => {
401
+ promises = ["Second", "Third", "Fourth"].map((name) => result.current.submit({ payload: { name } }));
402
+ });
403
+ await waitFor(() => {
404
+ expect(calls.filter((call) => !call.settled)).toHaveLength(1);
405
+ });
406
+ const lastCall = calls.find((call) => !call.settled)!;
407
+
408
+ await act(async () => {
409
+ lastCall.succeed({ id: 4, name: "Fourth" });
410
+ await Promise.all(promises);
411
+ });
412
+
413
+ expect(lastCall.request.payload).toStrictEqual({ name: "Fourth" });
414
+ expect(spies.success).toHaveBeenCalledTimes(1);
415
+ await waitFor(() => {
416
+ expect(result.current.data).toStrictEqual({ id: 4, name: "Fourth" });
417
+ });
418
+ });
419
+ it("should release the listeners of the canceled requests", async () => {
420
+ const { request, waitForCall, countListeners } = setup({ cancelable: true });
421
+ const { result } = renderSubmit(request);
422
+ const idleListeners = countListeners();
423
+ const promises: Promise<unknown>[] = [];
424
+ act(() => {
425
+ promises.push(result.current.submit({ payload: { name: "First" } }));
426
+ });
427
+ await waitForCall(0);
428
+ act(() => {
429
+ promises.push(result.current.submit({ payload: { name: "Second" } }));
430
+ });
431
+ const secondCall = await waitForCall(1);
432
+
433
+ await act(async () => {
434
+ secondCall.succeed({ id: 2, name: "Second" });
435
+ await Promise.all(promises);
436
+ });
437
+
438
+ await waitFor(() => {
439
+ expect(countListeners()).toBe(idleListeners);
440
+ });
441
+ });
442
+ });
443
+
444
+ describe("given the request is deduplicated", () => {
445
+ it("should send one request for the submits made while it is in flight", async () => {
446
+ const { request, waitForCall, calls } = setup({ deduplicate: true });
447
+ const { result } = renderSubmit(request);
448
+
449
+ act(() => {
450
+ result.current.submit({ payload: { name: "Maciej" } });
451
+ result.current.submit({ payload: { name: "Maciej" } });
452
+ result.current.submit({ payload: { name: "Maciej" } });
453
+ });
454
+ await waitForCall(0);
455
+
456
+ expect(calls).toHaveLength(1);
457
+ });
458
+ it("should resolve every submit with the shared response", async () => {
459
+ const { request, waitForCall } = setup({ deduplicate: true });
460
+ const { result } = renderSubmit(request);
461
+ let promises: ReturnType<typeof result.current.submit>[] = [];
462
+ act(() => {
463
+ promises = [1, 2].map(() => result.current.submit({ payload: { name: "Maciej" } }));
464
+ });
465
+ const call = await waitForCall(0);
466
+
467
+ act(() => {
468
+ call.succeed({ id: 1, name: "Maciej" });
469
+ });
470
+
471
+ const responses = await Promise.all(promises);
472
+ expect(responses.map((response) => response.data)).toStrictEqual([
473
+ { id: 1, name: "Maciej" },
474
+ { id: 1, name: "Maciej" },
475
+ ]);
476
+ });
477
+ it("should call the callbacks once for the shared response", async () => {
478
+ const { request, waitForCall } = setup({ deduplicate: true });
479
+ const { result, spies } = renderSubmit(request);
480
+ let promises: Promise<unknown>[] = [];
481
+ act(() => {
482
+ promises = [1, 2, 3].map(() => result.current.submit({ payload: { name: "Maciej" } }));
483
+ });
484
+ const call = await waitForCall(0);
485
+
486
+ await act(async () => {
487
+ call.succeed({ id: 1, name: "Maciej" });
488
+ await Promise.all(promises);
489
+ });
490
+
491
+ expect(spies.success).toHaveBeenCalledTimes(1);
492
+ expect(spies.finished).toHaveBeenCalledTimes(1);
493
+ });
494
+ it("should send a new request once the previous one is done", async () => {
495
+ const { request, waitForCall } = setup({ deduplicate: true });
496
+ const { result } = renderSubmit(request);
497
+ let promise: Promise<unknown> = Promise.resolve();
498
+ act(() => {
499
+ promise = result.current.submit({ payload: { name: "Maciej" } });
500
+ });
501
+ const firstCall = await waitForCall(0);
502
+ await act(async () => {
503
+ firstCall.succeed({ id: 1, name: "Maciej" });
504
+ await promise;
505
+ });
506
+
507
+ act(() => {
508
+ result.current.submit({ payload: { name: "Maciej" } });
509
+ });
510
+
511
+ const secondCall = await waitForCall(1);
512
+ expect(secondCall.requestId).not.toBe(firstCall.requestId);
513
+ });
514
+ it("should release the listeners once the shared request is done", async () => {
515
+ const { request, waitForCall, countListeners } = setup({ deduplicate: true });
516
+ const { result } = renderSubmit(request);
517
+ const idleListeners = countListeners();
518
+ let promises: Promise<unknown>[] = [];
519
+ act(() => {
520
+ promises = [1, 2].map(() => result.current.submit({ payload: { name: "Maciej" } }));
521
+ });
522
+ const call = await waitForCall(0);
523
+
524
+ await act(async () => {
525
+ call.succeed({ id: 1, name: "Maciej" });
526
+ await Promise.all(promises);
527
+ });
528
+
529
+ await waitFor(() => {
530
+ expect(countListeners()).toBe(idleListeners);
531
+ });
532
+ });
533
+ it("should leave no listeners behind after the unmount", async () => {
534
+ const { request, waitForCall, countListeners } = setup({ deduplicate: true });
535
+ const baseline = countListeners();
536
+ const { result, unmount } = renderSubmit(request);
537
+ let promises: Promise<unknown>[] = [];
538
+ act(() => {
539
+ promises = [1, 2].map(() => result.current.submit({ payload: { name: "Maciej" } }));
540
+ });
541
+ const call = await waitForCall(0);
542
+ await act(async () => {
543
+ call.succeed({ id: 1, name: "Maciej" });
544
+ await Promise.all(promises);
545
+ });
546
+
547
+ unmount();
548
+
549
+ expect(countListeners()).toBe(baseline);
550
+ });
551
+ });
552
+ });