@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,745 @@
1
+ import { Client } from "@hyper-fetch/core";
2
+ import { act, render, renderHook, screen, waitFor } from "@testing-library/react";
3
+ import { useFetch } from "hooks/use-fetch";
4
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
5
+ import React, { StrictMode } 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, mockListPost, calls, resetCalls } = createListServer();
17
+
18
+ type Post = { id: number };
19
+
20
+ const ids = (items: Post[]) => items.map((item) => item.id);
21
+
22
+ describe("useInfiniteFetch [ Base ]", () => {
23
+ let client: Client;
24
+
25
+ const createPosts = () =>
26
+ client.createRequest<{ response: Post[]; queryParams: { page?: number; limit?: number } }>()({
27
+ endpoint: "/posts",
28
+ });
29
+
30
+ const createFeed = () =>
31
+ client.createRequest<{
32
+ response: { data: Post[]; nextCursor: string | null; previousCursor?: string | null };
33
+ queryParams: { cursor?: string; topic?: string };
34
+ }>()({ endpoint: "/feed" });
35
+
36
+ const createUsers = () =>
37
+ client.createRequest<{
38
+ response: { users: Post[]; total: number };
39
+ queryParams: { offset?: number; limit?: number };
40
+ }>()({ endpoint: "/users" });
41
+
42
+ const mockPosts = (lastPage = 3, size = 2) => {
43
+ mockList("/posts", ({ query }) => {
44
+ const page = Number(query.page);
45
+ return page > lastPage ? [] : pageItems(page, size);
46
+ });
47
+ };
48
+
49
+ const mockFeed = () => {
50
+ mockList("/feed", ({ query }) => {
51
+ const page = Number(query.cursor ?? 1);
52
+ return {
53
+ data: pageItems(page),
54
+ nextCursor: page < 3 ? String(page + 1) : null,
55
+ previousCursor: page > 1 ? String(page - 1) : null,
56
+ };
57
+ });
58
+ };
59
+
60
+ beforeAll(() => startServer());
61
+ afterAll(() => stopServer());
62
+
63
+ beforeEach(() => {
64
+ client = new Client({ url: baseUrl });
65
+ resetCalls();
66
+ });
67
+
68
+ afterEach(async () => {
69
+ await settleRequests(client);
70
+ resetMocks();
71
+ });
72
+
73
+ describe("page numbers", () => {
74
+ it("should start from the first page and glue the next ones together", async () => {
75
+ mockPosts();
76
+ const { result } = renderHook(() =>
77
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
78
+ );
79
+
80
+ expect(result.current.loading).toBe(true);
81
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1, 2]));
82
+ expect(result.current.loading).toBe(false);
83
+ expect(calls.map((call) => call.query.page)).toEqual(["1"]);
84
+
85
+ await act(() => result.current.fetchNextPage());
86
+
87
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
88
+ expect(result.current.pages).toHaveLength(2);
89
+ expect(result.current.pageParams).toEqual([1, 2]);
90
+ expect(calls.map((call) => call.query.page)).toEqual(["1", "2"]);
91
+ });
92
+
93
+ it("should finish on an empty page when the page size is unknown", async () => {
94
+ mockPosts(1);
95
+ const { result } = renderHook(() =>
96
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
97
+ );
98
+
99
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
100
+ expect(result.current.hasNextPage).toBe(true);
101
+
102
+ await act(() => result.current.fetchNextPage());
103
+
104
+ expect(result.current.hasNextPage).toBe(false);
105
+ expect(ids(result.current.items)).toEqual([1, 2]);
106
+ });
107
+
108
+ it("should finish on a page shorter than the limit without another request", async () => {
109
+ mockList("/posts", () => [{ id: 1 }]);
110
+ const { result } = renderHook(() =>
111
+ useInfiniteFetch(createPosts().setQueryParams({ limit: 2 }), {
112
+ pagination: { page: "page", limit: "limit" },
113
+ dependencyTracking: false,
114
+ }),
115
+ );
116
+
117
+ await waitFor(() => expect(result.current.items).toHaveLength(1));
118
+
119
+ expect(result.current.hasNextPage).toBe(false);
120
+ await act(() => result.current.fetchNextPage());
121
+ expect(calls).toHaveLength(1);
122
+ });
123
+
124
+ it("should start from the page set on the request and go back from it", async () => {
125
+ mockPosts(9);
126
+ const { result } = renderHook(() =>
127
+ useInfiniteFetch(createPosts().setQueryParams({ page: 3 }), {
128
+ pagination: { page: "page" },
129
+ dependencyTracking: false,
130
+ }),
131
+ );
132
+
133
+ await waitFor(() => expect(ids(result.current.items)).toEqual([5, 6]));
134
+ expect(result.current.hasPreviousPage).toBe(true);
135
+
136
+ await act(() => result.current.fetchPreviousPage());
137
+ expect(ids(result.current.items)).toEqual([3, 4, 5, 6]);
138
+
139
+ await act(() => result.current.fetchPreviousPage());
140
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
141
+ expect(result.current.hasPreviousPage).toBe(false);
142
+ });
143
+
144
+ it("should treat a list starting at zero as numbered from zero", async () => {
145
+ mockList("/posts", () => [{ id: 1 }]);
146
+ const { result } = renderHook(() =>
147
+ useInfiniteFetch(createPosts().setQueryParams({ page: 0 }), {
148
+ pagination: { page: "page" },
149
+ dependencyTracking: false,
150
+ }),
151
+ );
152
+
153
+ await waitFor(() => expect(result.current.items).toHaveLength(1));
154
+
155
+ expect(calls[0].query.page).toBe("0");
156
+ expect(result.current.hasPreviousPage).toBe(false);
157
+ });
158
+
159
+ it("should use the hasNext override", async () => {
160
+ mockPosts();
161
+ const { result } = renderHook(() =>
162
+ useInfiniteFetch(createPosts(), {
163
+ pagination: { page: "page", hasNext: ({ param }) => Number(param) < 2 },
164
+ dependencyTracking: false,
165
+ }),
166
+ );
167
+
168
+ await waitFor(() => expect(result.current.hasNextPage).toBe(true));
169
+ await act(() => result.current.fetchNextPage());
170
+
171
+ expect(result.current.hasNextPage).toBe(false);
172
+ });
173
+ });
174
+
175
+ describe("offsets", () => {
176
+ it("should move by the limit and stop at the total", async () => {
177
+ mockList("/users", ({ query }) => {
178
+ const offset = Number(query.offset);
179
+ return { users: [{ id: offset + 1 }, { id: offset + 2 }], total: 4 };
180
+ });
181
+ const { result } = renderHook(() =>
182
+ useInfiniteFetch(createUsers().setQueryParams({ limit: 2 }), {
183
+ pagination: { offset: "offset", limit: "limit", items: "users", total: "total" },
184
+ dependencyTracking: false,
185
+ }),
186
+ );
187
+
188
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1, 2]));
189
+ expect(result.current.total).toBe(4);
190
+ expect(result.current.hasNextPage).toBe(true);
191
+
192
+ await act(() => result.current.fetchNextPage());
193
+
194
+ expect(calls.map((call) => call.query.offset)).toEqual(["0", "2"]);
195
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
196
+ expect(result.current.hasNextPage).toBe(false);
197
+ });
198
+
199
+ it("should go back by the limit without passing zero", async () => {
200
+ mockList("/users", ({ query }) => ({ users: [{ id: Number(query.offset) }], total: 100 }));
201
+ const { result } = renderHook(() =>
202
+ useInfiniteFetch(createUsers().setQueryParams({ offset: 1, limit: 2 }), {
203
+ pagination: { offset: "offset", limit: "limit", items: "users", total: "total" },
204
+ dependencyTracking: false,
205
+ }),
206
+ );
207
+
208
+ await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
209
+ await act(() => result.current.fetchPreviousPage());
210
+
211
+ expect(calls[1].query.offset).toBe("0");
212
+ expect(result.current.hasPreviousPage).toBe(false);
213
+ });
214
+ });
215
+
216
+ describe("cursors", () => {
217
+ it("should follow the cursor named by a response field", async () => {
218
+ mockFeed();
219
+ const { result } = renderHook(() =>
220
+ useInfiniteFetch(createFeed().setQueryParams({ topic: "a" }), {
221
+ pagination: { cursor: "cursor", next: "nextCursor", items: "data" },
222
+ dependencyTracking: false,
223
+ }),
224
+ );
225
+
226
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1, 2]));
227
+ expect(calls[0].query).toEqual({ topic: "a" });
228
+
229
+ await act(() => result.current.fetchNextPage());
230
+ await act(() => result.current.fetchNextPage());
231
+
232
+ expect(calls.map((call) => call.query.cursor)).toEqual([undefined, "2", "3"]);
233
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
234
+ expect(result.current.hasNextPage).toBe(false);
235
+ });
236
+
237
+ it("should accept functions for the cursor, items and total", async () => {
238
+ mockFeed();
239
+ const { result } = renderHook(() =>
240
+ useInfiniteFetch(createFeed(), {
241
+ pagination: {
242
+ cursor: "cursor",
243
+ next: ({ data }) => data.nextCursor,
244
+ items: ({ data }) => data.data.filter((post) => post.id % 2 === 0),
245
+ total: ({ pages }) => pages.length * 10,
246
+ },
247
+ dependencyTracking: false,
248
+ }),
249
+ );
250
+
251
+ await waitFor(() => expect(ids(result.current.items)).toEqual([2]));
252
+ expect(result.current.total).toBe(10);
253
+ });
254
+
255
+ it("should page backwards with the previous cursor", async () => {
256
+ mockFeed();
257
+ const { result } = renderHook(() =>
258
+ useInfiniteFetch(createFeed().setQueryParams({ cursor: "2" }), {
259
+ pagination: { cursor: "cursor", next: "nextCursor", previous: "previousCursor", items: "data" },
260
+ dependencyTracking: false,
261
+ }),
262
+ );
263
+
264
+ await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
265
+ await act(() => result.current.fetchPreviousPage());
266
+
267
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
268
+ expect(result.current.hasPreviousPage).toBe(false);
269
+ });
270
+ });
271
+
272
+ describe("paging outside of the query params", () => {
273
+ it("should page through URL params", async () => {
274
+ mockList("/archive/:page", ({ path }) => [{ id: Number(path.split("/").pop()) }]);
275
+ const request = client.createRequest<{ response: Post[] }>()({ endpoint: "/archive/:page" });
276
+
277
+ const { result } = renderHook(() =>
278
+ useInfiniteFetch(request.setParams({ page: 1 }), {
279
+ pagination: { page: "page", in: "params" },
280
+ dependencyTracking: false,
281
+ }),
282
+ );
283
+
284
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1]));
285
+ await act(() => result.current.fetchNextPage());
286
+
287
+ expect(calls.map((call) => call.path)).toEqual(["/archive/1", "/archive/2"]);
288
+ expect(ids(result.current.items)).toEqual([1, 2]);
289
+ });
290
+
291
+ it("should keep pages paged through the payload apart in the cache", async () => {
292
+ mockListPost("/search", ({ body }) => [{ id: body.page }]);
293
+ const request = client.createRequest<{ response: Post[]; payload: { page: number } }>()({
294
+ endpoint: "/search",
295
+ method: "POST",
296
+ });
297
+
298
+ const { result } = renderHook(() =>
299
+ useInfiniteFetch(request.setPayload({ page: 1 }), {
300
+ pagination: { page: "page", in: "payload" },
301
+ dependencyTracking: false,
302
+ }),
303
+ );
304
+
305
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1]));
306
+ await act(() => result.current.fetchNextPage());
307
+
308
+ expect(calls.map((call) => call.body.page)).toEqual([1, 2]);
309
+ expect(ids(result.current.items)).toEqual([1, 2]);
310
+ expect(client.cache.keys()).toHaveLength(2);
311
+ });
312
+
313
+ it("should keep pages of a request with a custom cache key apart", async () => {
314
+ mockPosts();
315
+ const { result } = renderHook(() =>
316
+ useInfiniteFetch(createPosts().setCacheKey("posts"), {
317
+ pagination: { page: "page" },
318
+ dependencyTracking: false,
319
+ }),
320
+ );
321
+
322
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
323
+ await act(() => result.current.fetchNextPage());
324
+
325
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
326
+ expect(client.cache.keys()).toHaveLength(2);
327
+ });
328
+ });
329
+
330
+ describe("list options", () => {
331
+ it("should keep only maxPages going forwards", async () => {
332
+ mockPosts(9);
333
+ const { result } = renderHook(() =>
334
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, maxPages: 2, dependencyTracking: false }),
335
+ );
336
+
337
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
338
+ await act(() => result.current.fetchNextPage());
339
+ await act(() => result.current.fetchNextPage());
340
+
341
+ expect(result.current.pageParams).toEqual([2, 3]);
342
+ expect(result.current.hasPreviousPage).toBe(true);
343
+ });
344
+
345
+ it("should keep only maxPages going backwards", async () => {
346
+ mockPosts(9);
347
+ const { result } = renderHook(() =>
348
+ useInfiniteFetch(createPosts().setQueryParams({ page: 5 }), {
349
+ pagination: { page: "page" },
350
+ maxPages: 2,
351
+ dependencyTracking: false,
352
+ }),
353
+ );
354
+
355
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
356
+ await act(() => result.current.fetchPreviousPage());
357
+ await act(() => result.current.fetchPreviousPage());
358
+
359
+ expect(result.current.pageParams).toEqual([3, 4]);
360
+ expect(result.current.hasNextPage).toBe(true);
361
+ });
362
+
363
+ it("should go back to cursor pages dropped by maxPages without a previous cursor", async () => {
364
+ mockFeed();
365
+ const { result } = renderHook(() =>
366
+ useInfiniteFetch(createFeed(), {
367
+ pagination: { cursor: "cursor", next: "nextCursor", items: "data" },
368
+ maxPages: 1,
369
+ dependencyTracking: false,
370
+ }),
371
+ );
372
+
373
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
374
+ expect(result.current.hasPreviousPage).toBe(false);
375
+
376
+ await act(() => result.current.fetchNextPage());
377
+ expect(ids(result.current.items)).toEqual([3, 4]);
378
+ expect(result.current.hasPreviousPage).toBe(true);
379
+
380
+ await act(() => result.current.fetchPreviousPage());
381
+ expect(ids(result.current.items)).toEqual([1, 2]);
382
+ });
383
+
384
+ it("should drop repeated items by a field and by a function", async () => {
385
+ mockList("/posts", ({ query }) => (query.page === "1" ? [{ id: 1 }, { id: 2 }] : [{ id: 2 }, { id: 3 }]));
386
+
387
+ const byField = renderHook(() =>
388
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, uniqueBy: "id", dependencyTracking: false }),
389
+ );
390
+ await waitFor(() => expect(byField.result.current.items).toHaveLength(2));
391
+ await act(() => byField.result.current.fetchNextPage());
392
+ expect(ids(byField.result.current.items)).toEqual([1, 2, 3]);
393
+
394
+ const byFunction = renderHook(() =>
395
+ useInfiniteFetch(createPosts(), {
396
+ pagination: { page: "page" },
397
+ uniqueBy: ({ item }) => item.id,
398
+ dependencyTracking: false,
399
+ }),
400
+ );
401
+ expect(ids(byFunction.result.current.items)).toEqual([1, 2, 3]);
402
+ });
403
+
404
+ it("should transform the list with select", async () => {
405
+ mockPosts();
406
+ const { result } = renderHook(() =>
407
+ useInfiniteFetch(createPosts(), {
408
+ pagination: { page: "page" },
409
+ select: ({ items, pages }) => ({ count: items.length, pages: pages.length }),
410
+ dependencyTracking: false,
411
+ }),
412
+ );
413
+
414
+ await waitFor(() => expect(result.current.items).toEqual({ count: 2, pages: 1 }));
415
+ });
416
+
417
+ it("should keep the selected reference when the result did not change", async () => {
418
+ mockPosts();
419
+ const { result, rerender } = renderHook(() =>
420
+ useInfiniteFetch(createPosts(), {
421
+ pagination: { page: "page" },
422
+ select: ({ items }) => items.map((item) => ({ ...item })),
423
+ dependencyTracking: false,
424
+ }),
425
+ );
426
+
427
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
428
+ const { items } = result.current;
429
+ rerender();
430
+
431
+ expect(result.current.items).toBe(items);
432
+ });
433
+
434
+ it("should throw a clear error without the pagination", () => {
435
+ const spy = vi.spyOn(console, "error").mockImplementation(() => null);
436
+
437
+ expect(() => renderHook(() => useInfiniteFetch(createPosts(), {} as any))).toThrow('"pagination" option');
438
+
439
+ spy.mockRestore();
440
+ });
441
+ });
442
+
443
+ describe("fetching", () => {
444
+ it("should share one request between calls made while a page loads", async () => {
445
+ mockPosts();
446
+ const { result } = renderHook(() =>
447
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
448
+ );
449
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
450
+
451
+ let first: Promise<unknown> = Promise.resolve();
452
+ let second: Promise<unknown> = Promise.resolve();
453
+ act(() => {
454
+ first = result.current.fetchNextPage();
455
+ second = result.current.fetchNextPage();
456
+ });
457
+
458
+ expect(first).toBe(second);
459
+ expect(result.current.isFetchingNextPage).toBe(true);
460
+ await act(async () => {
461
+ await first;
462
+ });
463
+
464
+ expect(calls.filter((call) => call.query.page === "2")).toHaveLength(1);
465
+ expect(result.current.isFetchingNextPage).toBe(false);
466
+ });
467
+
468
+ it("should keep the list and report the direction of a failed page", async () => {
469
+ mockList("/posts", ({ query }) => (query.page === "2" ? failure() : pageItems(Number(query.page))));
470
+ const { result } = renderHook(() =>
471
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
472
+ );
473
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
474
+
475
+ await act(() => result.current.fetchNextPage());
476
+
477
+ expect(result.current.isFetchNextPageError).toBe(true);
478
+ expect(result.current.isFetchPreviousPageError).toBe(false);
479
+ expect(result.current.error).toBeTruthy();
480
+ expect(ids(result.current.items)).toEqual([1, 2]);
481
+ expect(result.current.hasNextPage).toBe(true);
482
+
483
+ mockPosts();
484
+ await act(() => result.current.fetchNextPage());
485
+
486
+ expect(result.current.isFetchNextPageError).toBe(false);
487
+ expect(result.current.error).toBeNull();
488
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
489
+ });
490
+
491
+ it("should report a failed first page and retry it on refetch", async () => {
492
+ mockList("/posts", () => failure());
493
+ const { result } = renderHook(() =>
494
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
495
+ );
496
+
497
+ await waitFor(() => expect(result.current.error).toBeTruthy());
498
+ expect(result.current.loading).toBe(false);
499
+ expect(result.current.items).toEqual([]);
500
+ expect(result.current.hasNextPage).toBe(false);
501
+
502
+ mockPosts();
503
+ await act(() => result.current.refetch());
504
+
505
+ expect(result.current.error).toBeNull();
506
+ expect(ids(result.current.items)).toEqual([1, 2]);
507
+ });
508
+
509
+ it("should not fetch while disabled", async () => {
510
+ mockPosts();
511
+ const { result, rerender } = renderHook(
512
+ ({ disabled }) =>
513
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, disabled, dependencyTracking: false }),
514
+ { initialProps: { disabled: true } },
515
+ );
516
+
517
+ expect(result.current.loading).toBe(false);
518
+ await new Promise((resolve) => {
519
+ setTimeout(resolve, 30);
520
+ });
521
+ expect(calls).toHaveLength(0);
522
+
523
+ rerender({ disabled: false });
524
+
525
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
526
+ });
527
+
528
+ it("should send one request in StrictMode", async () => {
529
+ mockPosts();
530
+ const { result } = renderHook(
531
+ () => useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
532
+ { wrapper: StrictMode },
533
+ );
534
+
535
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
536
+
537
+ expect(calls).toHaveLength(1);
538
+ });
539
+
540
+ it("should cancel the pages being fetched with abort", async () => {
541
+ const gate = createDeferred();
542
+ mockList("/posts", async ({ query }) => {
543
+ if (query.page === "2") {
544
+ await gate.promise;
545
+ }
546
+ return pageItems(Number(query.page));
547
+ });
548
+ const { result } = renderHook(() =>
549
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
550
+ );
551
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
552
+
553
+ let pending: Promise<unknown> = Promise.resolve();
554
+ act(() => {
555
+ pending = result.current.fetchNextPage();
556
+ });
557
+ await waitFor(() => expect(calls).toHaveLength(2));
558
+
559
+ act(() => result.current.abort());
560
+ expect(result.current.isFetchingNextPage).toBe(false);
561
+
562
+ await expect(pending).resolves.toBeNull();
563
+ gate.resolve();
564
+
565
+ expect(ids(result.current.items)).toEqual([1, 2]);
566
+ expect(result.current.error).toBeNull();
567
+ });
568
+
569
+ it("should keep working after unmounting mid-fetch", async () => {
570
+ const gate = createDeferred();
571
+ mockList("/posts", async () => {
572
+ await gate.promise;
573
+ return pageItems(1);
574
+ });
575
+ const spy = vi.spyOn(console, "error");
576
+ const { unmount } = renderHook(() =>
577
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
578
+ );
579
+
580
+ await waitFor(() => expect(calls).toHaveLength(1));
581
+ unmount();
582
+ gate.resolve();
583
+
584
+ await waitFor(() => expect(client.cache.keys()).toHaveLength(1));
585
+ expect(spy).not.toHaveBeenCalled();
586
+ spy.mockRestore();
587
+ });
588
+
589
+ it("should report every page through the callbacks", async () => {
590
+ mockList("/posts", ({ query }) => (query.page === "2" ? failure() : pageItems(1)));
591
+ const onSuccess = vi.fn();
592
+ const onError = vi.fn();
593
+ const onFinished = vi.fn();
594
+
595
+ const { result } = renderHook(() => {
596
+ const list = useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false });
597
+ list.onSuccess(onSuccess);
598
+ list.onError(onError);
599
+ list.onFinished(onFinished);
600
+ return list;
601
+ });
602
+
603
+ await waitFor(() => expect(onSuccess).toHaveBeenCalledTimes(1));
604
+ expect(onSuccess.mock.calls[0][0].param).toBe(1);
605
+
606
+ await act(() => result.current.fetchNextPage());
607
+
608
+ expect(onError).toHaveBeenCalledTimes(1);
609
+ expect(onError.mock.calls[0][0].param).toBe(2);
610
+ expect(onFinished).toHaveBeenCalledTimes(2);
611
+ });
612
+ });
613
+
614
+ describe("shared data", () => {
615
+ it("should keep two hooks on one list in sync with one request per page", async () => {
616
+ mockPosts();
617
+ const pagination = { page: "page" } as const;
618
+ const { result } = renderHook(() => ({
619
+ first: useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }),
620
+ second: useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }),
621
+ }));
622
+
623
+ await waitFor(() => expect(result.current.second.items).toHaveLength(2));
624
+ await act(() => result.current.first.fetchNextPage());
625
+
626
+ expect(ids(result.current.second.items)).toEqual([1, 2, 3, 4]);
627
+ expect(calls).toHaveLength(2);
628
+ });
629
+
630
+ it("should share the page cache with a plain useFetch", async () => {
631
+ mockPosts();
632
+ const list = renderHook(() =>
633
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
634
+ );
635
+ await waitFor(() => expect(list.result.current.items).toHaveLength(2));
636
+
637
+ const single = renderHook(() =>
638
+ useFetch(createPosts().setQueryParams({ page: 1 }), { revalidate: false, dependencyTracking: false }),
639
+ );
640
+
641
+ expect(single.result.current.data).toEqual(pageItems(1));
642
+ expect(calls).toHaveLength(1);
643
+ });
644
+
645
+ it("should reuse a page already being fetched by another hook", async () => {
646
+ const gate = createDeferred();
647
+ mockList("/posts", async () => {
648
+ await gate.promise;
649
+ return pageItems(1);
650
+ });
651
+ // Without the deduplication of the dispatcher, joining the running request is up to the hook
652
+ const request = createPosts().setDeduplicate(false);
653
+ renderHook(() => useFetch(request.setQueryParams({ page: 1 })));
654
+ await waitFor(() => expect(calls).toHaveLength(1));
655
+
656
+ const { result } = renderHook(() =>
657
+ useInfiniteFetch(request, { pagination: { page: "page" }, dependencyTracking: false }),
658
+ );
659
+ gate.resolve();
660
+
661
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
662
+ expect(calls).toHaveLength(1);
663
+ });
664
+
665
+ it("should update a loaded page in place when its cache changes", async () => {
666
+ mockPosts();
667
+ const { result } = renderHook(() =>
668
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
669
+ );
670
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
671
+ await act(() => result.current.fetchNextPage());
672
+
673
+ const untouched = result.current.items[0];
674
+
675
+ act(() => {
676
+ client.cache.update(createPosts().setQueryParams({ page: 2 }), (previous) => ({
677
+ data: previous?.data?.map((post) => ({ ...post, id: post.id * 10 })),
678
+ }));
679
+ });
680
+
681
+ expect(ids(result.current.items)).toEqual([1, 2, 30, 40]);
682
+ expect(result.current.items[0]).toBe(untouched);
683
+ expect(calls).toHaveLength(2);
684
+ });
685
+
686
+ it("should keep references of unchanged items after a refetch", async () => {
687
+ mockPosts();
688
+ const { result } = renderHook(() =>
689
+ useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false }),
690
+ );
691
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
692
+ const { items, pages } = result.current;
693
+
694
+ await act(() => result.current.refetch());
695
+
696
+ expect(result.current.items).toBe(items);
697
+ expect(result.current.pages).toBe(pages);
698
+ });
699
+
700
+ it("should not mix up scopes of the same list", async () => {
701
+ mockPosts();
702
+ const pagination = { page: "page" } as const;
703
+ const { result } = renderHook(() => ({
704
+ a: useInfiniteFetch(createPosts().setScope("a"), { pagination, dependencyTracking: false }),
705
+ b: useInfiniteFetch(createPosts().setScope("b"), { pagination, dependencyTracking: false }),
706
+ }));
707
+ await waitFor(() => expect(result.current.a.items).toHaveLength(2));
708
+ await waitFor(() => expect(result.current.b.items).toHaveLength(2));
709
+
710
+ act(() => {
711
+ client.cache.update(createPosts().setQueryParams({ page: 1 }).setScope("a"), () => ({ data: [{ id: 99 }] }));
712
+ });
713
+
714
+ expect(ids(result.current.a.items)).toEqual([99]);
715
+ expect(ids(result.current.b.items)).toEqual([1, 2]);
716
+ });
717
+ });
718
+
719
+ describe("rendering", () => {
720
+ it("should rerender only for the values used by the component", async () => {
721
+ mockPosts();
722
+ let renders = 0;
723
+
724
+ const Component = () => {
725
+ renders += 1;
726
+ const { items, fetchNextPage } = useInfiniteFetch(createPosts(), { pagination: { page: "page" } });
727
+ return (
728
+ <button type="button" onClick={() => fetchNextPage()}>
729
+ {items.length}
730
+ </button>
731
+ );
732
+ };
733
+
734
+ render(<Component />);
735
+ await screen.findByText("2");
736
+ const rendersAfterLoad = renders;
737
+
738
+ act(() => screen.getByRole("button").click());
739
+ await screen.findByText("4");
740
+
741
+ // Only the arrival of new items matters, the fetching flags are not read
742
+ expect(renders).toBe(rendersAfterLoad + 1);
743
+ });
744
+ });
745
+ });