@hyper-fetch/react 9.6.0 → 9.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (102) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  3. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  4. package/__tests__/features/helpers/utils.spec.ts +127 -0
  5. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  6. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  7. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  8. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  9. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  10. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  11. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  12. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  13. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  14. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  15. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  16. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  17. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  18. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  19. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  20. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  21. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  22. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  23. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  24. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  25. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  26. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  27. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  29. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  30. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  31. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  32. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  33. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  34. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  35. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  36. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  37. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  38. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  39. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  40. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  41. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  42. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  43. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  44. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  45. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  46. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  47. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  48. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  49. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  50. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  51. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  52. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  53. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  54. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +8 -1
  55. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  56. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  57. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  58. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  59. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  60. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +2 -1
  61. package/__tests__/utils/gate.utils.ts +103 -0
  62. package/__tests__/utils/gated-client.utils.ts +158 -0
  63. package/__tests__/utils/helpers.utils.ts +19 -0
  64. package/__tests__/utils/use-queue.utils.ts +8 -4
  65. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  66. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  67. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  68. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  69. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  70. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  71. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  73. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  74. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  75. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  76. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  77. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  78. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  79. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  80. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  81. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  82. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  83. package/dist/index.mjs +633 -347
  84. package/dist/index.mjs.map +1 -1
  85. package/dist/provider/provider.d.ts.map +1 -1
  86. package/package.json +1 -1
  87. package/src/helpers/use-request-events/use-request-events.hooks.ts +147 -32
  88. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  89. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  90. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  91. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  92. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  93. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  94. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  95. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  96. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  97. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  98. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  99. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  100. package/src/provider/provider.tsx +9 -1
  101. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  102. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,446 @@
1
+ import { act, render, renderHook, screen, waitFor } from "@testing-library/react";
2
+ import { useSubmit } from "hooks/use-submit";
3
+
4
+ import { createGatedClient } from "../../utils/gated-client.utils";
5
+
6
+ type User = { id: number; name: string };
7
+
8
+ const setup = () => {
9
+ const gated = createGatedClient();
10
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
11
+ endpoint: "/users",
12
+ method: "POST",
13
+ });
14
+ /** Renders the hook and finishes one submit with the given outcome */
15
+ const renderSubmitted = async (outcome: "success" | "error" = "success") => {
16
+ const view = renderHook(() => useSubmit(request, { dependencyTracking: false }));
17
+ let promise: Promise<unknown> = Promise.resolve();
18
+ act(() => {
19
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
20
+ });
21
+ const call = await gated.waitForCall(0);
22
+ await act(async () => {
23
+ if (outcome === "success") {
24
+ call.succeed({ id: 1, name: "Maciej" });
25
+ } else {
26
+ call.fail({ message: "Nope" }, 400);
27
+ }
28
+ await promise;
29
+ });
30
+ await waitFor(() => {
31
+ expect(view.result.current.responseTimestamp).toBeDate();
32
+ });
33
+ return view;
34
+ };
35
+ return { ...gated, request, renderSubmitted };
36
+ };
37
+
38
+ describe("useSubmit [ Actions ]", () => {
39
+ describe("when changing the state by hand", () => {
40
+ it("should set the data", () => {
41
+ const { request } = setup();
42
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false }));
43
+
44
+ act(() => {
45
+ result.current.setData({ id: 5, name: "Local" });
46
+ });
47
+
48
+ expect(result.current.data).toStrictEqual({ id: 5, name: "Local" });
49
+ });
50
+ it("should set the data based on the previous value", async () => {
51
+ const { renderSubmitted } = setup();
52
+ const { result } = await renderSubmitted();
53
+
54
+ act(() => {
55
+ result.current.setData((previous) => (previous ? { ...previous, name: `${previous.name}!` } : null));
56
+ });
57
+
58
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej!" });
59
+ });
60
+ it("should clear the data", async () => {
61
+ const { renderSubmitted } = setup();
62
+ const { result } = await renderSubmitted();
63
+
64
+ act(() => {
65
+ result.current.setData(null);
66
+ });
67
+
68
+ expect(result.current.data).toBeNull();
69
+ });
70
+ it("should set and clear the error", async () => {
71
+ const { renderSubmitted } = setup();
72
+ const { result } = await renderSubmitted("error");
73
+ expect(result.current.error).toStrictEqual({ message: "Nope" });
74
+
75
+ act(() => {
76
+ result.current.setError(null);
77
+ });
78
+ expect(result.current.error).toBeNull();
79
+
80
+ act(() => {
81
+ result.current.setError(new Error("Local error"));
82
+ });
83
+ expect(result.current.error).toStrictEqual(new Error("Local error"));
84
+ });
85
+ it("should set the submitting state with setLoading", () => {
86
+ const { request } = setup();
87
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false }));
88
+
89
+ act(() => {
90
+ result.current.setLoading(true);
91
+ });
92
+ expect(result.current.submitting).toBeTrue();
93
+
94
+ act(() => {
95
+ result.current.setLoading(false);
96
+ });
97
+ expect(result.current.submitting).toBeFalse();
98
+ });
99
+ it("should set the status, success, extra and retries", () => {
100
+ const { request } = setup();
101
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false }));
102
+
103
+ act(() => {
104
+ result.current.setStatus(202);
105
+ result.current.setSuccess(true);
106
+ result.current.setExtra({ headers: { "x-test": "1" } });
107
+ result.current.setRetries(3);
108
+ });
109
+
110
+ expect(result.current.status).toBe(202);
111
+ expect(result.current.success).toBeTrue();
112
+ expect(result.current.extra).toStrictEqual({ headers: { "x-test": "1" } });
113
+ expect(result.current.retries).toBe(3);
114
+ });
115
+ it("should set the timestamps", () => {
116
+ const { request } = setup();
117
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false }));
118
+ const requestDate = new Date(2020, 1, 1);
119
+ const responseDate = new Date(2020, 1, 2);
120
+
121
+ act(() => {
122
+ result.current.setRequestTimestamp(requestDate);
123
+ result.current.setResponseTimestamp(responseDate);
124
+ });
125
+
126
+ expect(result.current.requestTimestamp).toStrictEqual(requestDate);
127
+ expect(result.current.responseTimestamp).toStrictEqual(responseDate);
128
+ });
129
+ it("should keep the local changes inside of the hook", async () => {
130
+ const { request, client, renderSubmitted } = setup();
131
+ const { result } = await renderSubmitted();
132
+ const other = renderHook(() => useSubmit(request, { dependencyTracking: false }));
133
+
134
+ act(() => {
135
+ result.current.setData({ id: 5, name: "Local" });
136
+ });
137
+
138
+ expect(other.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
139
+ expect(client.cache.get(request.cacheKey)?.data).toStrictEqual({ id: 1, name: "Maciej" });
140
+ });
141
+ it("should replace the local data with the next response", async () => {
142
+ const { waitForCall, renderSubmitted } = setup();
143
+ const { result } = await renderSubmitted();
144
+ act(() => {
145
+ result.current.setData({ id: 5, name: "Local" });
146
+ });
147
+
148
+ act(() => {
149
+ result.current.submit({ payload: { name: "Kacper" } });
150
+ });
151
+ const call = await waitForCall(1);
152
+ act(() => {
153
+ call.succeed({ id: 2, name: "Kacper" });
154
+ });
155
+
156
+ await waitFor(() => {
157
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Kacper" });
158
+ });
159
+ });
160
+ });
161
+
162
+ describe("when clearing the state", () => {
163
+ it("should clear the result of a successful submit", async () => {
164
+ const { renderSubmitted } = setup();
165
+ const { result } = await renderSubmitted();
166
+
167
+ act(() => {
168
+ result.current.clearState();
169
+ });
170
+
171
+ expect(result.current.data).toBeNull();
172
+ expect(result.current.error).toBeNull();
173
+ expect(result.current.status).toBeNull();
174
+ expect(result.current.success).toBeFalse();
175
+ expect(result.current.submitting).toBeFalse();
176
+ expect(result.current.retries).toBe(0);
177
+ expect(result.current.requestTimestamp).toBeNull();
178
+ expect(result.current.responseTimestamp).toBeNull();
179
+ });
180
+ it("should reset extra to its initial value", async () => {
181
+ const { request, renderSubmitted } = setup();
182
+ const initial = renderHook(() => useSubmit(request, { dependencyTracking: false })).result.current.extra;
183
+ const { result } = await renderSubmitted();
184
+ expect(result.current.extra).not.toStrictEqual(initial);
185
+
186
+ act(() => {
187
+ result.current.clearState();
188
+ });
189
+
190
+ expect(initial).toStrictEqual({ headers: {} });
191
+ expect(result.current.extra).toStrictEqual(initial);
192
+ });
193
+ it("should clear the result of a failed submit", async () => {
194
+ const { renderSubmitted } = setup();
195
+ const { result } = await renderSubmitted("error");
196
+
197
+ act(() => {
198
+ result.current.clearState();
199
+ });
200
+
201
+ expect(result.current.error).toBeNull();
202
+ expect(result.current.status).toBeNull();
203
+ });
204
+ it("should allow to submit again afterwards", async () => {
205
+ const { waitForCall, renderSubmitted } = setup();
206
+ const { result } = await renderSubmitted("error");
207
+ act(() => {
208
+ result.current.clearState();
209
+ });
210
+
211
+ act(() => {
212
+ result.current.submit({ payload: { name: "Kacper" } });
213
+ });
214
+ const call = await waitForCall(1);
215
+ expect(result.current.submitting).toBeTrue();
216
+ act(() => {
217
+ call.succeed({ id: 2, name: "Kacper" });
218
+ });
219
+
220
+ await waitFor(() => {
221
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Kacper" });
222
+ });
223
+ expect(result.current.success).toBeTrue();
224
+ });
225
+ it("should not clear the state of another hook using the same request", async () => {
226
+ const { request, renderSubmitted } = setup();
227
+ const { result } = await renderSubmitted();
228
+ const other = renderHook(() => useSubmit(request, { dependencyTracking: false }));
229
+
230
+ act(() => {
231
+ result.current.clearState();
232
+ });
233
+
234
+ expect(other.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
235
+ });
236
+ });
237
+
238
+ describe("when using the initialResponse option", () => {
239
+ it("should start with the given response", () => {
240
+ const { request } = setup();
241
+ const { result } = renderHook(() =>
242
+ useSubmit(request, {
243
+ dependencyTracking: false,
244
+ initialResponse: { data: { id: 7, name: "Draft" }, status: 200 },
245
+ }),
246
+ );
247
+
248
+ expect(result.current.data).toStrictEqual({ id: 7, name: "Draft" });
249
+ expect(result.current.status).toBe(200);
250
+ expect(result.current.submitting).toBeFalse();
251
+ });
252
+ it("should not send any request for the initial response", async () => {
253
+ const { request, calls, client } = setup();
254
+ renderHook(() =>
255
+ useSubmit(request, { dependencyTracking: false, initialResponse: { data: { id: 7, name: "Draft" } } }),
256
+ );
257
+
258
+ expect(calls).toHaveLength(0);
259
+ expect(client.submitDispatcher.getAllRunningRequests()).toHaveLength(0);
260
+ });
261
+ it("should replace the initial response with the real one", async () => {
262
+ const { request, waitForCall } = setup();
263
+ const { result } = renderHook(() =>
264
+ useSubmit(request, { dependencyTracking: false, initialResponse: { data: { id: 7, name: "Draft" } } }),
265
+ );
266
+
267
+ act(() => {
268
+ result.current.submit({ payload: { name: "Maciej" } });
269
+ });
270
+ const call = await waitForCall(0);
271
+ act(() => {
272
+ call.succeed({ id: 1, name: "Maciej" });
273
+ });
274
+
275
+ await waitFor(() => {
276
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
277
+ });
278
+ });
279
+ });
280
+
281
+ describe("when using the select option", () => {
282
+ it("should keep the selected part of the response in the data", async () => {
283
+ const { request, waitForCall } = setup();
284
+ const { result } = renderHook(() =>
285
+ useSubmit(request, { dependencyTracking: false, select: (user) => user.name.toUpperCase() }),
286
+ );
287
+
288
+ act(() => {
289
+ result.current.submit({ payload: { name: "Maciej" } });
290
+ });
291
+ const call = await waitForCall(0);
292
+ act(() => {
293
+ call.succeed({ id: 1, name: "Maciej" });
294
+ });
295
+
296
+ await waitFor(() => {
297
+ expect(result.current.data).toBe("MACIEJ");
298
+ });
299
+ });
300
+ it("should pass the full response to the callbacks", async () => {
301
+ const { request, waitForCall } = setup();
302
+ const success = vi.fn();
303
+ const { result } = renderHook(() => {
304
+ const view = useSubmit(request, { dependencyTracking: false, select: (user) => user.name });
305
+ view.onSubmitSuccess(success);
306
+ return view;
307
+ });
308
+ let promise: Promise<unknown> = Promise.resolve();
309
+
310
+ act(() => {
311
+ promise = result.current.submit({ payload: { name: "Maciej" } });
312
+ });
313
+ const call = await waitForCall(0);
314
+ await act(async () => {
315
+ call.succeed({ id: 1, name: "Maciej" });
316
+ await promise;
317
+ });
318
+
319
+ expect(success.mock.calls[0][0].response.data).toStrictEqual({ id: 1, name: "Maciej" });
320
+ });
321
+ it("should select again when the selector changes", async () => {
322
+ const { request, waitForCall } = setup();
323
+ const { result, rerender } = renderHook(
324
+ ({ field }: { field: keyof User }) =>
325
+ useSubmit(request, { dependencyTracking: false, select: (user) => user[field] }),
326
+ { initialProps: { field: "name" as keyof User } },
327
+ );
328
+ act(() => {
329
+ result.current.submit({ payload: { name: "Maciej" } });
330
+ });
331
+ const call = await waitForCall(0);
332
+ act(() => {
333
+ call.succeed({ id: 1, name: "Maciej" });
334
+ });
335
+ await waitFor(() => {
336
+ expect(result.current.data).toBe("Maciej");
337
+ });
338
+
339
+ rerender({ field: "id" });
340
+
341
+ expect(result.current.data).toBe(1);
342
+ });
343
+ it("should keep the data empty until the first response", () => {
344
+ const { request } = setup();
345
+ const select = vi.fn((user: User) => user.name);
346
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false, select }));
347
+
348
+ expect(result.current.data).toBeNull();
349
+ expect(select).not.toHaveBeenCalled();
350
+ });
351
+ });
352
+
353
+ describe("when the component reads only a part of the state", () => {
354
+ it("should not rerender a component that reads only the submit function", async () => {
355
+ const { request, waitForCall } = setup();
356
+ let renders = 0;
357
+ let submit: ReturnType<typeof useSubmit<typeof request>>["submit"] | null = null;
358
+ function Page() {
359
+ renders += 1;
360
+ ({ submit } = useSubmit(request));
361
+ return <div>form</div>;
362
+ }
363
+ render(<Page />);
364
+ let promise: Promise<unknown> = Promise.resolve();
365
+
366
+ act(() => {
367
+ promise = submit!({ payload: { name: "Maciej" } });
368
+ });
369
+ const call = await waitForCall(0);
370
+ await act(async () => {
371
+ call.succeed({ id: 1, name: "Maciej" });
372
+ await promise;
373
+ });
374
+
375
+ expect(renders).toBe(1);
376
+ });
377
+ it("should rerender a component that reads the submitting state", async () => {
378
+ const { request, waitForCall } = setup();
379
+ let submit: ReturnType<typeof useSubmit<typeof request>>["submit"] | null = null;
380
+ function Page() {
381
+ const view = useSubmit(request);
382
+ ({ submit } = view);
383
+ return <div data-testid="state">{view.submitting ? "saving" : "idle"}</div>;
384
+ }
385
+ render(<Page />);
386
+
387
+ act(() => {
388
+ submit!({ payload: { name: "Maciej" } });
389
+ });
390
+ const call = await waitForCall(0);
391
+ expect(screen.getByTestId("state").textContent).toBe("saving");
392
+ act(() => {
393
+ call.succeed({ id: 1, name: "Maciej" });
394
+ });
395
+
396
+ await waitFor(() => {
397
+ expect(screen.getByTestId("state").textContent).toBe("idle");
398
+ });
399
+ });
400
+ it("should rerender a component that reads the data only when the data changes", async () => {
401
+ const { request, waitForCall } = setup();
402
+ const rendered: (string | null)[] = [];
403
+ let submit: ReturnType<typeof useSubmit<typeof request>>["submit"] | null = null;
404
+ function Page() {
405
+ const view = useSubmit(request);
406
+ ({ submit } = view);
407
+ rendered.push(view.data?.name ?? null);
408
+ return <div data-testid="state">{view.data?.name ?? "none"}</div>;
409
+ }
410
+ render(<Page />);
411
+
412
+ act(() => {
413
+ submit!({ payload: { name: "Maciej" } });
414
+ });
415
+ const call = await waitForCall(0);
416
+ act(() => {
417
+ call.succeed({ id: 1, name: "Maciej" });
418
+ });
419
+
420
+ await waitFor(() => {
421
+ expect(screen.getByTestId("state").textContent).toBe("Maciej");
422
+ });
423
+ expect(rendered).toStrictEqual([null, "Maciej"]);
424
+ });
425
+ it("should keep the data reference when the same response comes again", async () => {
426
+ const { waitForCall, renderSubmitted } = setup();
427
+ const { result } = await renderSubmitted();
428
+ const firstData = result.current.data;
429
+ let promise: Promise<unknown> = Promise.resolve();
430
+
431
+ act(() => {
432
+ promise = result.current.submit({ payload: { name: "Maciej" } });
433
+ });
434
+ const call = await waitForCall(1);
435
+ await act(async () => {
436
+ call.succeed({ id: 1, name: "Maciej" });
437
+ await promise;
438
+ });
439
+ await waitFor(() => {
440
+ expect(result.current.submitting).toBeFalse();
441
+ });
442
+
443
+ expect(result.current.data).toBe(firstData);
444
+ });
445
+ });
446
+ });