@hyper-fetch/react 9.5.1 → 9.6.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 (52) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.mapper-failure.spec.ts +215 -0
  2. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
  3. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
  4. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
  5. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
  6. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
  7. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
  8. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
  9. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
  10. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +310 -0
  11. package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
  12. package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
  13. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  14. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  15. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  16. package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
  17. package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
  18. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
  19. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
  20. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
  21. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
  22. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
  23. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
  24. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
  25. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
  26. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
  27. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
  28. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
  29. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
  30. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
  31. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
  32. package/dist/index.d.ts +1 -0
  33. package/dist/index.d.ts.map +1 -1
  34. package/dist/index.mjs +934 -13
  35. package/dist/index.mjs.map +1 -1
  36. package/dist/provider/provider.types.d.ts +2 -0
  37. package/dist/provider/provider.types.d.ts.map +1 -1
  38. package/package.json +2 -3
  39. package/src/helpers/use-request-events/use-request-events.hooks.ts +13 -7
  40. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +3 -5
  41. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +4 -5
  42. package/src/hooks/use-infinite-fetch/index.ts +3 -0
  43. package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
  44. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
  45. package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
  46. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
  47. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
  48. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
  49. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
  50. package/src/index.ts +1 -0
  51. package/src/provider/provider.types.ts +3 -0
  52. package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
@@ -0,0 +1,567 @@
1
+ import { Client } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import { useFetch } from "hooks/use-fetch";
4
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
5
+ import { useLayoutEffect } from "react";
6
+
7
+ import {
8
+ baseUrl,
9
+ createDeferred,
10
+ createListServer,
11
+ failure,
12
+ pageItems,
13
+ settleRequests,
14
+ } from "../../utils/use-infinite-fetch.utils";
15
+
16
+ const { startServer, stopServer, resetMocks, mockList, calls, resetCalls } = createListServer();
17
+
18
+ type Post = { id: number; version?: number };
19
+
20
+ const ids = (items: Post[]) => items.map((item) => item.id);
21
+
22
+ const sleep = (time: number) =>
23
+ new Promise((resolve) => {
24
+ setTimeout(resolve, time);
25
+ });
26
+
27
+ describe("useInfiniteFetch [ Refetch ]", () => {
28
+ let client: Client;
29
+
30
+ const createPosts = () =>
31
+ client.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({ endpoint: "/posts" });
32
+
33
+ const createFeed = () =>
34
+ client.createRequest<{
35
+ response: { data: Post[]; nextCursor: string | null };
36
+ queryParams: { cursor?: string };
37
+ }>()({ endpoint: "/feed" });
38
+
39
+ const pagination = { page: "page" } as const;
40
+ const feedPagination = { cursor: "cursor", next: "nextCursor", items: "data" } as const;
41
+
42
+ const renderPosts = async (pages = 2, options: Record<string, unknown> = {}) => {
43
+ const view = renderHook(() =>
44
+ useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false, ...options }),
45
+ );
46
+ await waitFor(() => expect(view.result.current.pageParams).toHaveLength(1));
47
+ for (let page = 1; page < pages; page += 1) {
48
+ // Pages depend on the previous ones
49
+ // eslint-disable-next-line no-await-in-loop
50
+ await act(() => view.result.current.fetchNextPage());
51
+ }
52
+ return view;
53
+ };
54
+
55
+ beforeAll(() => startServer());
56
+ afterAll(() => stopServer());
57
+
58
+ beforeEach(() => {
59
+ client = new Client({ url: baseUrl });
60
+ resetCalls();
61
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)));
62
+ });
63
+
64
+ afterEach(async () => {
65
+ await settleRequests(client);
66
+ resetMocks();
67
+ });
68
+
69
+ describe("page numbers", () => {
70
+ it("should refetch all the pages at the same time", async () => {
71
+ const { result } = await renderPosts(3);
72
+ resetCalls();
73
+
74
+ let running = 0;
75
+ let mostRunning = 0;
76
+ mockList("/posts", async ({ query }) => {
77
+ running += 1;
78
+ mostRunning = Math.max(mostRunning, running);
79
+ await sleep(20);
80
+ running -= 1;
81
+ return pageItems(Number(query.page));
82
+ });
83
+
84
+ await act(() => result.current.refetch());
85
+
86
+ expect(calls.map((call) => call.query.page).toSorted()).toEqual(["1", "2", "3"]);
87
+ expect(mostRunning).toBe(3);
88
+ });
89
+
90
+ it("should show the old pages until all of them arrive", async () => {
91
+ const { result } = await renderPosts(2);
92
+ const gate = createDeferred();
93
+
94
+ mockList("/posts", async ({ query }) => {
95
+ if (query.page === "2") {
96
+ await gate.promise;
97
+ }
98
+ return pageItems(Number(query.page)).map((post) => ({ ...post, version: 2 }));
99
+ });
100
+
101
+ let pending: Promise<unknown> = Promise.resolve();
102
+ act(() => {
103
+ pending = result.current.refetch();
104
+ });
105
+ expect(result.current.isRefetching).toBe(true);
106
+
107
+ await waitFor(() => expect(createPosts().setQueryParams({ page: 1 }).read()?.data?.[0].version).toBe(2));
108
+ expect(result.current.items.map((item) => item.version)).toEqual([undefined, undefined, undefined, undefined]);
109
+
110
+ gate.resolve();
111
+ await act(async () => {
112
+ await pending;
113
+ });
114
+
115
+ expect(result.current.items.map((item) => item.version)).toEqual([2, 2, 2, 2]);
116
+ expect(result.current.isRefetching).toBe(false);
117
+ });
118
+
119
+ it("should keep the old data of a page that failed to refetch", async () => {
120
+ const { result } = await renderPosts(2);
121
+
122
+ mockList("/posts", ({ query }) => {
123
+ return query.page === "2" ? failure() : pageItems(1).map((post) => ({ ...post, version: 2 }));
124
+ });
125
+ await act(() => result.current.refetch());
126
+
127
+ expect(result.current.items.map((item) => item.version)).toEqual([2, 2, undefined, undefined]);
128
+ expect(result.current.error).toBeTruthy();
129
+ });
130
+ });
131
+
132
+ describe("cursors", () => {
133
+ it("should refetch in order, following the fresh cursors", async () => {
134
+ mockList("/feed", ({ query }) => {
135
+ const page = Number(query.cursor ?? 1);
136
+ return { data: pageItems(page), nextCursor: page < 3 ? String(page + 1) : null };
137
+ });
138
+ const { result } = renderHook(() =>
139
+ useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
140
+ );
141
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
142
+ await act(() => result.current.fetchNextPage());
143
+ resetCalls();
144
+
145
+ mockList("/feed", ({ query }) => {
146
+ if (!query.cursor) {
147
+ return { data: [{ id: 100 }], nextCursor: "fresh" };
148
+ }
149
+ return { data: [{ id: 200 }], nextCursor: null };
150
+ });
151
+ await act(() => result.current.refetch());
152
+
153
+ expect(calls.map((call) => call.query.cursor)).toEqual([undefined, "fresh"]);
154
+ expect(ids(result.current.items)).toEqual([100, 200]);
155
+ expect(result.current.hasNextPage).toBe(false);
156
+ });
157
+
158
+ it("should stop at a list that became shorter", async () => {
159
+ mockList("/feed", ({ query }) => {
160
+ return { data: pageItems(Number(query.cursor ?? 1)), nextCursor: query.cursor ? null : "2" };
161
+ });
162
+ const { result } = renderHook(() =>
163
+ useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
164
+ );
165
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
166
+ await act(() => result.current.fetchNextPage());
167
+
168
+ mockList("/feed", () => ({ data: [{ id: 1 }], nextCursor: null }));
169
+ await act(() => result.current.refetch());
170
+
171
+ expect(ids(result.current.items)).toEqual([1]);
172
+ });
173
+
174
+ it("should leave the list alone when a page of the chain fails", async () => {
175
+ mockList("/feed", ({ query }) => {
176
+ return { data: pageItems(Number(query.cursor ?? 1)), nextCursor: query.cursor ? null : "2" };
177
+ });
178
+ const { result } = renderHook(() =>
179
+ useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
180
+ );
181
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
182
+ await act(() => result.current.fetchNextPage());
183
+
184
+ mockList("/feed", ({ query }) => {
185
+ return query.cursor ? failure() : { data: [{ id: 100 }], nextCursor: "2" };
186
+ });
187
+ await act(() => result.current.refetch());
188
+
189
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
190
+ expect(result.current.error).toBeTruthy();
191
+ });
192
+ });
193
+
194
+ describe("triggers", () => {
195
+ it("should refetch the chain when one page is invalidated", async () => {
196
+ await renderPosts(2);
197
+ resetCalls();
198
+
199
+ act(() => {
200
+ client.cache.invalidate(createPosts().setQueryParams({ page: 2 }));
201
+ });
202
+
203
+ await waitFor(() => expect(calls).toHaveLength(2));
204
+ });
205
+
206
+ it("should handle invalidating many pages with one refetch", async () => {
207
+ await renderPosts(3);
208
+ resetCalls();
209
+ const add = vi.spyOn(client.fetchDispatcher, "add");
210
+
211
+ act(() => {
212
+ client.cache.invalidate(/posts/);
213
+ });
214
+
215
+ await waitFor(() => expect(calls).toHaveLength(3));
216
+ await sleep(30);
217
+ expect(calls).toHaveLength(3);
218
+ expect(add).toHaveBeenCalledTimes(3);
219
+ });
220
+
221
+ it("should fetch again when a page is invalidated during a refetch", async () => {
222
+ const { result } = await renderPosts(1);
223
+ const gate = createDeferred();
224
+ let version = 0;
225
+
226
+ mockList("/posts", async () => {
227
+ version += 1;
228
+ const current = version;
229
+ if (current === 1) {
230
+ await gate.promise;
231
+ }
232
+ return [{ id: 1, version: current }];
233
+ });
234
+
235
+ act(() => {
236
+ result.current.refetch();
237
+ });
238
+ await waitFor(() => expect(version).toBe(1));
239
+
240
+ await act(async () => {
241
+ client.cache.invalidate(createPosts().setQueryParams({ page: 1 }));
242
+ });
243
+
244
+ await waitFor(() => expect(result.current.items.map((item) => item.version)).toEqual([2]));
245
+ gate.resolve();
246
+ await sleep(20);
247
+ expect(result.current.items.map((item) => item.version)).toEqual([2]);
248
+ });
249
+
250
+ it("should refetch when a loaded page is deleted", async () => {
251
+ await renderPosts(1);
252
+ resetCalls();
253
+
254
+ act(() => {
255
+ client.cache.delete(createPosts().setQueryParams({ page: 1 }).cacheKey);
256
+ });
257
+
258
+ await waitFor(() => expect(calls).toHaveLength(1));
259
+ });
260
+
261
+ it("should ignore changes of pages outside of the list", async () => {
262
+ await renderPosts(1);
263
+ resetCalls();
264
+
265
+ act(() => {
266
+ client.cache.invalidate(createPosts().setQueryParams({ page: 7 }));
267
+ });
268
+
269
+ await sleep(30);
270
+ expect(calls).toHaveLength(0);
271
+ });
272
+
273
+ it("should refetch on focus and on reconnect when asked to", async () => {
274
+ await renderPosts(1, { refetchOnFocus: true, refetchOnReconnect: true });
275
+ resetCalls();
276
+
277
+ act(() => client.appManager.events.emitFocus());
278
+ await waitFor(() => expect(calls).toHaveLength(1));
279
+ await sleep(20);
280
+
281
+ act(() => client.appManager.events.emitOnline());
282
+ await waitFor(() => expect(calls).toHaveLength(2));
283
+ });
284
+
285
+ it("should not refetch on focus by default", async () => {
286
+ await renderPosts(1);
287
+ resetCalls();
288
+
289
+ act(() => client.appManager.events.emitFocus());
290
+
291
+ await sleep(30);
292
+ expect(calls).toHaveLength(0);
293
+ });
294
+
295
+ it("should refetch on the refresh interval", async () => {
296
+ await renderPosts(1, { refresh: true, refreshTime: 20 });
297
+ resetCalls();
298
+
299
+ await waitFor(() => expect(calls.length).toBeGreaterThanOrEqual(2));
300
+ });
301
+
302
+ it("should refetch when the dependencies change", async () => {
303
+ const { result, rerender } = renderHook(
304
+ ({ version }) =>
305
+ useInfiniteFetch(createPosts(), { pagination, dependencies: [version], dependencyTracking: false }),
306
+ { initialProps: { version: 1 } },
307
+ );
308
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
309
+ resetCalls();
310
+
311
+ rerender({ version: 2 });
312
+
313
+ await waitFor(() => expect(calls).toHaveLength(1));
314
+ });
315
+ });
316
+
317
+ describe("mounting", () => {
318
+ it("should restore every cached page without requests", async () => {
319
+ const first = await renderPosts(3);
320
+ first.unmount();
321
+ resetCalls();
322
+
323
+ const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
324
+
325
+ expect(result.current.pageParams).toEqual([1, 2, 3]);
326
+ expect(result.current.loading).toBe(false);
327
+ await sleep(30);
328
+ expect(calls).toHaveLength(0);
329
+ });
330
+
331
+ it("should refetch the restored pages when they are stale", async () => {
332
+ const stale = () => createPosts().setStaleTime(0);
333
+ const first = renderHook(() => useInfiniteFetch(stale(), { pagination, dependencyTracking: false }));
334
+ await waitFor(() => expect(first.result.current.items).toHaveLength(2));
335
+ await act(() => first.result.current.fetchNextPage());
336
+ first.unmount();
337
+ await sleep(5);
338
+ resetCalls();
339
+
340
+ const { result } = renderHook(() => useInfiniteFetch(stale(), { pagination, dependencyTracking: false }));
341
+
342
+ expect(result.current.pageParams).toEqual([1, 2]);
343
+ await waitFor(() => expect(calls).toHaveLength(2));
344
+ });
345
+
346
+ it("should refetch fresh pages with the revalidate option", async () => {
347
+ const first = await renderPosts(1);
348
+ first.unmount();
349
+ resetCalls();
350
+
351
+ renderHook(() => useInfiniteFetch(createPosts(), { pagination, revalidate: true, dependencyTracking: false }));
352
+
353
+ await waitFor(() => expect(calls).toHaveLength(1));
354
+ });
355
+
356
+ it("should not show pages after the cache was cleared", async () => {
357
+ const first = await renderPosts(2);
358
+ first.unmount();
359
+ await client.cache.clear();
360
+
361
+ const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
362
+
363
+ expect(result.current.items).toEqual([]);
364
+ expect(result.current.loading).toBe(true);
365
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
366
+ });
367
+
368
+ it("should pick up pages written between rendering and mounting", async () => {
369
+ const response = {
370
+ data: pageItems(1),
371
+ error: null,
372
+ status: 200,
373
+ success: true,
374
+ extra: {},
375
+ requestTimestamp: Date.now(),
376
+ responseTimestamp: Date.now(),
377
+ } as any;
378
+
379
+ const { result } = renderHook(() => {
380
+ useLayoutEffect(() => {
381
+ client.cache.set(createPosts().setQueryParams({ page: 1 }), response);
382
+ }, []);
383
+ return useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false, disabled: true });
384
+ });
385
+
386
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1, 2]));
387
+ expect(calls).toHaveLength(0);
388
+ });
389
+
390
+ it("should stop restoring at the first missing page", async () => {
391
+ const first = await renderPosts(3);
392
+ first.unmount();
393
+ client.cache.delete(createPosts().setQueryParams({ page: 2 }).cacheKey);
394
+
395
+ const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
396
+
397
+ expect(result.current.pageParams).toEqual([1]);
398
+ });
399
+ });
400
+
401
+ describe("overlapping fetches", () => {
402
+ it("should finish loading the next page before refetching", async () => {
403
+ const { result } = await renderPosts(1);
404
+ const gate = createDeferred();
405
+ resetCalls();
406
+
407
+ mockList("/posts", async ({ query }) => {
408
+ if (query.page === "2" && !calls.some((call) => call.query.page === "1")) {
409
+ await gate.promise;
410
+ }
411
+ return pageItems(Number(query.page));
412
+ });
413
+
414
+ let next: Promise<unknown> = Promise.resolve();
415
+ let refetch: Promise<unknown> = Promise.resolve();
416
+ act(() => {
417
+ next = result.current.fetchNextPage();
418
+ refetch = result.current.refetch();
419
+ });
420
+
421
+ await waitFor(() => expect(calls).toHaveLength(1));
422
+ expect(calls[0].query.page).toBe("2");
423
+
424
+ gate.resolve();
425
+ await act(async () => {
426
+ await Promise.all([next, refetch]);
427
+ });
428
+
429
+ expect(
430
+ calls
431
+ .map((call) => call.query.page)
432
+ .slice(1)
433
+ .toSorted(),
434
+ ).toEqual(["1", "2"]);
435
+ expect(result.current.pageParams).toEqual([1, 2]);
436
+ });
437
+
438
+ it("should replace a running refetch with a newer one", async () => {
439
+ const { result } = await renderPosts(1);
440
+ const gate = createDeferred();
441
+ let version = 0;
442
+
443
+ mockList("/posts", async () => {
444
+ version += 1;
445
+ const current = version;
446
+ if (current === 1) {
447
+ await gate.promise;
448
+ }
449
+ return [{ id: 1, version: current }];
450
+ });
451
+
452
+ let first: Promise<unknown> = Promise.resolve();
453
+ act(() => {
454
+ first = result.current.refetch();
455
+ });
456
+ await waitFor(() => expect(version).toBe(1));
457
+
458
+ await act(() => result.current.refetch());
459
+ gate.resolve();
460
+
461
+ await expect(first).resolves.toBeNull();
462
+ expect(result.current.items.map((item) => item.version)).toEqual([2]);
463
+ });
464
+
465
+ it("should join an automatic refetch instead of repeating it", async () => {
466
+ const { result } = await renderPosts(1, { refetchOnFocus: true });
467
+ const gate = createDeferred();
468
+ resetCalls();
469
+
470
+ mockList("/posts", async () => {
471
+ await gate.promise;
472
+ return pageItems(1);
473
+ });
474
+
475
+ act(() => {
476
+ result.current.refetch();
477
+ });
478
+ await waitFor(() => expect(calls).toHaveLength(1));
479
+
480
+ act(() => client.appManager.events.emitFocus());
481
+ await sleep(20);
482
+ expect(calls).toHaveLength(1);
483
+
484
+ await act(async () => {
485
+ gate.resolve();
486
+ });
487
+ });
488
+
489
+ it("should keep a change made to a page while the others are still refetching", async () => {
490
+ const { result } = await renderPosts(2);
491
+ const gate = createDeferred();
492
+
493
+ mockList("/posts", async ({ query }) => {
494
+ if (query.page === "2") {
495
+ await gate.promise;
496
+ }
497
+ return pageItems(Number(query.page));
498
+ });
499
+
500
+ let pending: Promise<unknown> = Promise.resolve();
501
+ act(() => {
502
+ pending = result.current.refetch();
503
+ });
504
+ const firstPage = createPosts().setQueryParams({ page: 1 });
505
+ const refetchedAt = firstPage.read()?.responseTimestamp;
506
+ await waitFor(() => expect(firstPage.read()?.responseTimestamp).not.toBe(refetchedAt));
507
+
508
+ act(() => {
509
+ client.cache.update(firstPage, () => ({ data: [{ id: 42 }] }));
510
+ });
511
+ gate.resolve();
512
+ await act(async () => {
513
+ await pending;
514
+ });
515
+
516
+ expect(ids(result.current.items)).toEqual([42, 3, 4]);
517
+ });
518
+
519
+ it("should not reuse an older running request for a manual refetch", async () => {
520
+ const gate = createDeferred();
521
+ const { result } = await renderPosts(1);
522
+ resetCalls();
523
+
524
+ mockList("/posts", async () => {
525
+ if (calls.length === 1) {
526
+ await gate.promise;
527
+ }
528
+ return pageItems(1);
529
+ });
530
+ renderHook(() => useFetch(createPosts().setQueryParams({ page: 1 }).setDeduplicate(true)));
531
+ await waitFor(() => expect(calls).toHaveLength(1));
532
+
533
+ await act(() => result.current.refetch());
534
+
535
+ expect(calls).toHaveLength(2);
536
+ gate.resolve();
537
+ });
538
+
539
+ it("should not report a page cancelled from the outside as an error", async () => {
540
+ const { result } = await renderPosts(1);
541
+ const gate = createDeferred();
542
+
543
+ mockList("/posts", async () => {
544
+ await gate.promise;
545
+ return pageItems(2);
546
+ });
547
+
548
+ let pending: Promise<unknown> = Promise.resolve();
549
+ act(() => {
550
+ pending = result.current.fetchNextPage();
551
+ });
552
+ await waitFor(() => expect(calls.length).toBeGreaterThan(1));
553
+
554
+ act(() => {
555
+ createPosts().setQueryParams({ page: 2 }).abort();
556
+ });
557
+ await act(async () => {
558
+ await pending;
559
+ });
560
+ gate.resolve();
561
+
562
+ expect(result.current.error).toBeNull();
563
+ expect(result.current.isFetchNextPageError).toBe(false);
564
+ expect(result.current.pageParams).toEqual([1]);
565
+ });
566
+ });
567
+ });