@hyper-fetch/react 9.6.1 → 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 (91) 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-settlement.spec.ts +6 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  48. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  49. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  50. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  51. package/__tests__/utils/gate.utils.ts +103 -0
  52. package/__tests__/utils/gated-client.utils.ts +158 -0
  53. package/__tests__/utils/helpers.utils.ts +19 -0
  54. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  55. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  57. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  60. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  61. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  69. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  70. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  72. package/dist/index.mjs +630 -346
  73. package/dist/index.mjs.map +1 -1
  74. package/dist/provider/provider.d.ts.map +1 -1
  75. package/package.json +1 -1
  76. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  77. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  78. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  79. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  80. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  81. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  82. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  83. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  84. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  85. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  86. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  87. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  88. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  89. package/src/provider/provider.tsx +9 -1
  90. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  91. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,1027 @@
1
+ /* eslint-disable react/state-in-constructor, react/no-set-state */
2
+ import { Client } from "@hyper-fetch/core";
3
+ import { act, render, renderHook, screen, waitFor } from "@testing-library/react";
4
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
5
+ import React, { StrictMode, Suspense, useState } from "react";
6
+ import { renderToString } from "react-dom/server";
7
+
8
+ import { countListeners } from "../../utils/gate.utils";
9
+ import {
10
+ baseUrl,
11
+ createDeferred,
12
+ createListServer,
13
+ failure,
14
+ pageItems,
15
+ settleRequests,
16
+ } from "../../utils/use-infinite-fetch.utils";
17
+
18
+ /**
19
+ * Scenarios known from the infinite queries of TanStack Query and SWR, checked against useInfiniteFetch.
20
+ * Only the behaviors are shared - the API and the tests are written for HyperFetch.
21
+ */
22
+
23
+ const { startServer, stopServer, resetMocks, mockList, calls, resetCalls } = createListServer();
24
+
25
+ type Post = { id: number; version?: number };
26
+ type Feed = { data: Post[]; next: string | null };
27
+
28
+ const ids = (items: Post[]) => items.map((item) => item.id);
29
+
30
+ class Boundary extends React.Component<{ children: React.ReactNode }, { hasError: boolean }> {
31
+ state = { hasError: false };
32
+
33
+ static getDerivedStateFromError() {
34
+ return { hasError: true };
35
+ }
36
+
37
+ render() {
38
+ return this.state.hasError ? <div>boundary</div> : this.props.children;
39
+ }
40
+ }
41
+
42
+ describe("useInfiniteFetch [ Parity ]", () => {
43
+ let client: Client;
44
+
45
+ const createPosts = () =>
46
+ client.createRequest<{ response: Post[]; queryParams: { page?: number; search?: string } }>()({
47
+ endpoint: "/posts",
48
+ });
49
+
50
+ const createFeed = () =>
51
+ client.createRequest<{ response: Feed; queryParams: { cursor?: string } }>()({ endpoint: "/feed" });
52
+
53
+ const createUsers = () =>
54
+ client.createRequest<{
55
+ response: { users: Post[]; total: number };
56
+ queryParams: { offset?: number; limit?: number };
57
+ }>()({ endpoint: "/users" });
58
+
59
+ const pagination = { page: "page" } as const;
60
+ const feedPagination = { cursor: "cursor", next: "next", items: "data" } as const;
61
+
62
+ const pagesOf = (page: string) => calls.filter((call) => call.query.page === page);
63
+
64
+ /** Resolves once every stored page is older than its stale time of zero */
65
+ const waitForStalePages = async (request: ReturnType<typeof createPosts>) => {
66
+ const { cacheKey } = request.setQueryParams({ page: 2 });
67
+ await waitFor(() => expect(client.cache.get(cacheKey)?.responseTimestamp).toBeLessThan(Date.now()));
68
+ };
69
+
70
+ const renderPosts = async (pages = 1) => {
71
+ const view = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
72
+ await waitFor(() => expect(view.result.current.pageParams).toHaveLength(1));
73
+ for (let page = 1; page < pages; page += 1) {
74
+ // Pages depend on the previous ones
75
+ // eslint-disable-next-line no-await-in-loop
76
+ await act(() => view.result.current.fetchNextPage());
77
+ }
78
+ return view;
79
+ };
80
+
81
+ beforeAll(() => startServer());
82
+ afterAll(() => stopServer());
83
+
84
+ beforeEach(() => {
85
+ client = new Client({ url: baseUrl });
86
+ resetCalls();
87
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)));
88
+ });
89
+
90
+ afterEach(async () => {
91
+ await settleRequests(client);
92
+ resetMocks();
93
+ });
94
+
95
+ describe("states", () => {
96
+ it("should return the correct states for a successful list", async () => {
97
+ const gates = new Map([
98
+ ["1", createDeferred()],
99
+ ["2", createDeferred()],
100
+ ]);
101
+ mockList("/posts", async ({ query }) => {
102
+ await gates.get(query.page)?.promise;
103
+ return pageItems(Number(query.page));
104
+ });
105
+
106
+ const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
107
+
108
+ expect(result.current.items).toEqual([]);
109
+ expect(result.current.pages).toEqual([]);
110
+ expect(result.current.pageParams).toEqual([]);
111
+ expect(result.current.total).toBeNull();
112
+ expect(result.current.loading).toBe(true);
113
+ expect(result.current.isFetching).toBe(true);
114
+ expect(result.current.isRefetching).toBe(false);
115
+ expect(result.current.isFetchingNextPage).toBe(false);
116
+ expect(result.current.isFetchingPreviousPage).toBe(false);
117
+ expect(result.current.hasNextPage).toBe(false);
118
+ expect(result.current.hasPreviousPage).toBe(false);
119
+ expect(result.current.isPreviousData).toBe(false);
120
+ expect(result.current.success).toBe(false);
121
+ expect(result.current.error).toBeNull();
122
+ expect(result.current.status).toBeNull();
123
+
124
+ gates.get("1")?.resolve();
125
+ await waitFor(() => expect(result.current.loading).toBe(false));
126
+
127
+ expect(result.current.items).toEqual(pageItems(1));
128
+ expect(result.current.pages).toEqual([pageItems(1)]);
129
+ expect(result.current.pageParams).toEqual([1]);
130
+ expect(result.current.isFetching).toBe(false);
131
+ expect(result.current.hasNextPage).toBe(true);
132
+ expect(result.current.hasPreviousPage).toBe(false);
133
+ expect(result.current.success).toBe(true);
134
+ expect(result.current.error).toBeNull();
135
+ expect(result.current.status).toBe(200);
136
+
137
+ let pending: Promise<unknown> = Promise.resolve();
138
+ act(() => {
139
+ pending = result.current.fetchNextPage();
140
+ });
141
+
142
+ expect(result.current.loading).toBe(false);
143
+ expect(result.current.isFetching).toBe(true);
144
+ expect(result.current.isFetchingNextPage).toBe(true);
145
+ expect(result.current.isRefetching).toBe(false);
146
+ expect(result.current.items).toEqual(pageItems(1));
147
+
148
+ gates.get("2")?.resolve();
149
+ await act(async () => {
150
+ await pending;
151
+ });
152
+
153
+ expect(result.current.pages).toEqual([pageItems(1), pageItems(2)]);
154
+ expect(result.current.pageParams).toEqual([1, 2]);
155
+ expect(result.current.isFetching).toBe(false);
156
+ expect(result.current.isFetchingNextPage).toBe(false);
157
+ expect(result.current.success).toBe(true);
158
+ });
159
+
160
+ it("should resolve with the error response when the next page fails", async () => {
161
+ mockList("/posts", ({ query }) => (query.page === "2" ? failure() : pageItems(Number(query.page))));
162
+ const { result } = await renderPosts();
163
+
164
+ let response: Awaited<ReturnType<typeof result.current.fetchNextPage>> = null;
165
+ await act(async () => {
166
+ response = await result.current.fetchNextPage();
167
+ });
168
+
169
+ expect(response).toMatchObject({ success: false, status: 500, data: null });
170
+ expect(result.current.status).toBe(500);
171
+ expect(result.current.success).toBe(false);
172
+ expect(result.current.pages).toEqual([pageItems(1)]);
173
+ });
174
+
175
+ it("should return the correct states when a refetch fails", async () => {
176
+ const { result } = await renderPosts(2);
177
+ const gate = createDeferred();
178
+ mockList("/posts", async ({ query }) => {
179
+ await gate.promise;
180
+ return query.page === "2" ? failure() : pageItems(Number(query.page));
181
+ });
182
+
183
+ let pending: Promise<unknown> = Promise.resolve();
184
+ act(() => {
185
+ pending = result.current.refetch();
186
+ });
187
+
188
+ expect(result.current.isRefetching).toBe(true);
189
+ expect(result.current.isFetching).toBe(true);
190
+ expect(result.current.loading).toBe(false);
191
+ expect(result.current.isFetchingNextPage).toBe(false);
192
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
193
+
194
+ gate.resolve();
195
+ await act(async () => {
196
+ await pending;
197
+ });
198
+
199
+ expect(result.current.isRefetching).toBe(false);
200
+ expect(result.current.isFetching).toBe(false);
201
+ expect(result.current.error).toBeTruthy();
202
+ expect(result.current.success).toBe(false);
203
+ expect(result.current.isFetchNextPageError).toBe(false);
204
+ expect(result.current.isFetchPreviousPageError).toBe(false);
205
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
206
+ });
207
+
208
+ it("should not call the pagination callbacks before a page is loaded", async () => {
209
+ const gate = createDeferred();
210
+ mockList("/feed", async () => {
211
+ await gate.promise;
212
+ return { data: pageItems(1), next: null };
213
+ });
214
+ const next = vi.fn(({ data }: { data: Feed }) => data.next);
215
+ const items = vi.fn(({ data }: { data: Feed }) => data.data);
216
+
217
+ const { result } = renderHook(() =>
218
+ useInfiniteFetch(createFeed(), { pagination: { cursor: "cursor", next, items }, dependencyTracking: false }),
219
+ );
220
+
221
+ expect(result.current.hasNextPage).toBe(false);
222
+ expect(result.current.hasPreviousPage).toBe(false);
223
+ expect(next).not.toHaveBeenCalled();
224
+ expect(items).not.toHaveBeenCalled();
225
+
226
+ gate.resolve();
227
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
228
+ expect(next).toHaveBeenCalled();
229
+ });
230
+ });
231
+
232
+ describe("end of the list", () => {
233
+ it("should continue after a cursor of zero", async () => {
234
+ mockList("/numbers", ({ query }) => {
235
+ return query.cursor === undefined ? { data: pageItems(1), next: 0 } : { data: pageItems(2), next: null };
236
+ });
237
+ const createNumbers = () =>
238
+ client.createRequest<{ response: { data: Post[]; next: number | null }; queryParams: { cursor?: number } }>()({
239
+ endpoint: "/numbers",
240
+ });
241
+
242
+ const { result } = renderHook(() =>
243
+ useInfiniteFetch(createNumbers(), { pagination: feedPagination, dependencyTracking: false }),
244
+ );
245
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
246
+
247
+ expect(result.current.hasNextPage).toBe(true);
248
+ await act(() => result.current.fetchNextPage());
249
+
250
+ expect(calls.at(-1)?.query.cursor).toBe("0");
251
+ expect(result.current.pageParams).toEqual([undefined, 0]);
252
+ expect(result.current.hasNextPage).toBe(false);
253
+ });
254
+
255
+ it("should compute hasNextPage from the pages, not from the selected value", async () => {
256
+ mockList("/feed", ({ query }) => ({
257
+ data: pageItems(Number(query.cursor ?? 1)),
258
+ next: query.cursor ? null : "2",
259
+ }));
260
+
261
+ const { result } = renderHook(() =>
262
+ useInfiniteFetch(createFeed(), {
263
+ pagination: feedPagination,
264
+ select: () => "nothing",
265
+ dependencyTracking: false,
266
+ }),
267
+ );
268
+ await waitFor(() => expect(result.current.pageParams).toHaveLength(1));
269
+
270
+ expect(result.current.items).toBe("nothing");
271
+ expect(result.current.hasNextPage).toBe(true);
272
+ await act(() => result.current.fetchNextPage());
273
+ expect(result.current.hasNextPage).toBe(false);
274
+ expect(result.current.pageParams).toEqual([undefined, "2"]);
275
+ });
276
+ });
277
+
278
+ describe("refetching", () => {
279
+ it("should drop the pages after the new end of a list that became shorter", async () => {
280
+ let lastPage = 3;
281
+ mockList("/posts", ({ query }) => (Number(query.page) > lastPage ? [] : pageItems(Number(query.page))));
282
+ const { result } = await renderPosts(3);
283
+ expect(result.current.pageParams).toEqual([1, 2, 3]);
284
+
285
+ lastPage = 1;
286
+ await act(() => result.current.refetch());
287
+
288
+ // The same list as when loaded from scratch: the empty page is the one that ended it
289
+ expect(result.current.pages).toEqual([pageItems(1), []]);
290
+ expect(result.current.pageParams).toEqual([1, 2]);
291
+ expect(result.current.hasNextPage).toBe(false);
292
+ expect(result.current.error).toBeNull();
293
+ });
294
+
295
+ it("should not keep a page that failed to refetch past the new end of the list", async () => {
296
+ let total = 6;
297
+ mockList("/users", ({ query }) => {
298
+ const offset = Number(query.offset);
299
+ if (offset >= total) {
300
+ return failure(404);
301
+ }
302
+ const users = pageItems(offset / 2 + 1).filter((user) => user.id <= total);
303
+ return { users, total };
304
+ });
305
+ const { result } = renderHook(() =>
306
+ useInfiniteFetch(createUsers().setQueryParams({ limit: 2 }), {
307
+ pagination: { offset: "offset", limit: "limit", items: "users", total: "total" },
308
+ dependencyTracking: false,
309
+ }),
310
+ );
311
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
312
+ await act(() => result.current.fetchNextPage());
313
+ await act(() => result.current.fetchNextPage());
314
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
315
+
316
+ total = 3;
317
+ await act(() => result.current.refetch());
318
+
319
+ expect(ids(result.current.items)).toEqual([1, 2, 3]);
320
+ expect(result.current.pageParams).toEqual([0, 2]);
321
+ expect(result.current.total).toBe(3);
322
+ expect(result.current.hasNextPage).toBe(false);
323
+ expect(result.current.error).toBeNull();
324
+ expect(result.current.success).toBe(true);
325
+ });
326
+
327
+ it("should load the next page after a running refetch, from its fresh cursor", async () => {
328
+ let version = "a";
329
+ const gate = createDeferred();
330
+ mockList("/feed", async ({ query }) => {
331
+ if (version === "b") {
332
+ await gate.promise;
333
+ }
334
+ const page = query.cursor ? Number(query.cursor.slice(1)) : 1;
335
+ return { data: pageItems(page), next: page < 3 ? `${version}${page + 1}` : null };
336
+ });
337
+ const { result } = renderHook(() =>
338
+ useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
339
+ );
340
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
341
+ version = "b";
342
+
343
+ let refetch: Promise<unknown> = Promise.resolve();
344
+ let next: Promise<unknown> = Promise.resolve();
345
+ act(() => {
346
+ refetch = result.current.refetch();
347
+ next = result.current.fetchNextPage();
348
+ });
349
+
350
+ expect(result.current.isRefetching).toBe(true);
351
+ expect(result.current.isFetchingNextPage).toBe(true);
352
+
353
+ gate.resolve();
354
+ await act(async () => {
355
+ await Promise.all([refetch, next]);
356
+ });
357
+
358
+ expect(calls.map((call) => call.query.cursor)).toEqual([undefined, undefined, "b2"]);
359
+ expect(result.current.pageParams).toEqual([undefined, "b2"]);
360
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
361
+ expect(result.current.isFetching).toBe(false);
362
+ });
363
+
364
+ it("should keep the restored pages visible when their refetch fails", async () => {
365
+ const stale = () => createPosts().setStaleTime(0);
366
+ const first = renderHook(() => useInfiniteFetch(stale(), { pagination, dependencyTracking: false }));
367
+ await waitFor(() => expect(first.result.current.items).toHaveLength(2));
368
+ await act(() => first.result.current.fetchNextPage());
369
+ first.unmount();
370
+ await waitForStalePages(stale());
371
+ mockList("/posts", () => failure());
372
+
373
+ const { result } = renderHook(() => useInfiniteFetch(stale(), { pagination, dependencyTracking: false }));
374
+
375
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
376
+ expect(result.current.loading).toBe(false);
377
+ await waitFor(() => expect(result.current.error).toBeTruthy());
378
+
379
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
380
+ expect(result.current.isFetching).toBe(false);
381
+ expect(result.current.hasNextPage).toBe(true);
382
+ });
383
+
384
+ it("should refetch the pages invalidated while the list was not mounted", async () => {
385
+ const first = await renderPosts(2);
386
+ first.unmount();
387
+ resetCalls();
388
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)).map((post) => ({ ...post, version: 2 })));
389
+
390
+ client.cache.invalidate();
391
+ const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
392
+
393
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
394
+ expect(result.current.loading).toBe(false);
395
+ await waitFor(() => expect(result.current.items.map((post) => post.version)).toEqual([2, 2, 2, 2]));
396
+ expect(calls.map((call) => call.query.page).toSorted()).toEqual(["1", "2"]);
397
+ });
398
+
399
+ it("should follow a cursor changed by a cache update", async () => {
400
+ mockList("/feed", ({ query }) => ({
401
+ data: pageItems(Number(query.cursor ?? 1)),
402
+ next: query.cursor ? null : "2",
403
+ }));
404
+ const { result } = renderHook(() =>
405
+ useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
406
+ );
407
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
408
+
409
+ act(() => {
410
+ client.cache.update(createFeed(), (previous) => ({
411
+ data: previous?.data ? { ...previous.data, next: "5" } : null,
412
+ }));
413
+ });
414
+ await act(() => result.current.fetchNextPage());
415
+
416
+ expect(calls.at(-1)?.query.cursor).toBe("5");
417
+ expect(result.current.pageParams).toEqual([undefined, "5"]);
418
+ expect(ids(result.current.items)).toEqual([1, 2, 9, 10]);
419
+ });
420
+ });
421
+
422
+ describe("retries", () => {
423
+ const retried = () => createPosts().setRetry(2).setRetryTime(1);
424
+
425
+ it("should retry a failing page without reporting the attempts or repeating other pages", async () => {
426
+ const gate = createDeferred();
427
+ mockList("/posts", async ({ query }) => {
428
+ if (query.page !== "2") {
429
+ return pageItems(Number(query.page));
430
+ }
431
+ if (pagesOf("2").length === 1) {
432
+ return failure();
433
+ }
434
+ await gate.promise;
435
+ return pageItems(2);
436
+ });
437
+ const { result } = renderHook(() => useInfiniteFetch(retried(), { pagination, dependencyTracking: false }));
438
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
439
+
440
+ let pending: Promise<unknown> = Promise.resolve();
441
+ act(() => {
442
+ pending = result.current.fetchNextPage();
443
+ });
444
+ await waitFor(() => expect(pagesOf("2")).toHaveLength(2));
445
+
446
+ expect(result.current.error).toBeNull();
447
+ expect(result.current.isFetchNextPageError).toBe(false);
448
+ expect(result.current.isFetchingNextPage).toBe(true);
449
+
450
+ gate.resolve();
451
+ await act(async () => {
452
+ await pending;
453
+ });
454
+
455
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
456
+ expect(result.current.error).toBeNull();
457
+ expect(pagesOf("1")).toHaveLength(1);
458
+ expect(pagesOf("2")).toHaveLength(2);
459
+ });
460
+
461
+ it("should stop when the retries run out", async () => {
462
+ mockList("/posts", ({ query }) => (query.page === "2" ? failure() : pageItems(Number(query.page))));
463
+ const { result } = renderHook(() => useInfiniteFetch(retried(), { pagination, dependencyTracking: false }));
464
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
465
+
466
+ await act(() => result.current.fetchNextPage());
467
+
468
+ expect(pagesOf("2")).toHaveLength(3);
469
+ expect(result.current.isFetchNextPageError).toBe(true);
470
+ expect(result.current.isFetching).toBe(false);
471
+ expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(0);
472
+ expect(ids(result.current.items)).toEqual([1, 2]);
473
+ });
474
+ });
475
+
476
+ describe("select", () => {
477
+ it("should not rerender endlessly with a select returning a new value", async () => {
478
+ let renders = 0;
479
+
480
+ const Component = () => {
481
+ renders += 1;
482
+ const { items } = useInfiniteFetch(createPosts(), {
483
+ pagination,
484
+ select: ({ items: posts }) => ({ ids: posts.map((post) => post.id) }),
485
+ });
486
+ return <span>{items.ids.join(",")}</span>;
487
+ };
488
+
489
+ render(<Component />);
490
+ await screen.findByText("1,2");
491
+ const rendersAfterLoad = renders;
492
+
493
+ await act(async () => {
494
+ await Promise.resolve();
495
+ });
496
+
497
+ expect(renders).toBe(rendersAfterLoad);
498
+ });
499
+
500
+ it("should report a throwing select through error, like a failed fetch", async () => {
501
+ const selectError = new Error("Too many posts");
502
+ let limit = 2;
503
+ const { result } = renderHook(() =>
504
+ useInfiniteFetch(createPosts(), {
505
+ pagination,
506
+ dependencyTracking: false,
507
+ select: ({ items: posts }) => {
508
+ if (posts.length > limit) {
509
+ throw selectError;
510
+ }
511
+ return posts.length;
512
+ },
513
+ }),
514
+ );
515
+ await waitFor(() => expect(result.current.items).toBe(2));
516
+
517
+ await act(() => result.current.fetchNextPage());
518
+
519
+ // The last selected value stays, the error says why it is not updated
520
+ expect(result.current.items).toBe(2);
521
+ expect(result.current.error).toBe(selectError);
522
+ expect(result.current.success).toBe(false);
523
+ expect(result.current.pages).toHaveLength(2);
524
+
525
+ limit = 10;
526
+ await act(() => result.current.refetch());
527
+
528
+ expect(result.current.items).toBe(4);
529
+ expect(result.current.error).toBeNull();
530
+ expect(result.current.success).toBe(true);
531
+ });
532
+
533
+ it("should give no selected value when select throws on the first page", async () => {
534
+ const selectError = new Error("Invalid page");
535
+ const { result } = renderHook(() =>
536
+ useInfiniteFetch(createPosts(), {
537
+ pagination,
538
+ dependencyTracking: false,
539
+ select: (): number => {
540
+ throw selectError;
541
+ },
542
+ }),
543
+ );
544
+
545
+ await waitFor(() => expect(result.current.pages).toHaveLength(1));
546
+ expect(result.current.error).toBe(selectError);
547
+ expect(result.current.success).toBe(false);
548
+ expect(result.current.items).toBeNull();
549
+ });
550
+
551
+ it("should not throw a failing select to the Error Boundary", async () => {
552
+ const Component = () => {
553
+ const { items, error } = useInfiniteFetch(createPosts(), {
554
+ pagination,
555
+ select: (): string => {
556
+ throw new Error("Broken select");
557
+ },
558
+ });
559
+ return <span>{error ? (error as Error).message : String(items)}</span>;
560
+ };
561
+
562
+ render(
563
+ <Boundary>
564
+ <Component />
565
+ </Boundary>,
566
+ );
567
+
568
+ await screen.findByText("Broken select");
569
+ expect(screen.queryByText("boundary")).toBeNull();
570
+ });
571
+
572
+ it("should throw a failing select to the Error Boundary with throwOnError", async () => {
573
+ const spy = vi.spyOn(console, "error").mockImplementation(() => null);
574
+ const Component = () => {
575
+ const { items } = useInfiniteFetch(createPosts(), {
576
+ pagination,
577
+ throwOnError: true,
578
+ select: (): string => {
579
+ throw new Error("Broken select");
580
+ },
581
+ });
582
+ return <span>{String(items)}</span>;
583
+ };
584
+
585
+ render(
586
+ <Boundary>
587
+ <Component />
588
+ </Boundary>,
589
+ );
590
+
591
+ await screen.findByText("boundary");
592
+ spy.mockRestore();
593
+ });
594
+ });
595
+
596
+ describe("direction errors", () => {
597
+ const failPage = (failed: string) => {
598
+ mockList("/posts", ({ query }) => (query.page === failed ? failure() : pageItems(Number(query.page))));
599
+ };
600
+
601
+ it("should clear isFetchNextPageError after a successful refetch", async () => {
602
+ const { result } = await renderPosts();
603
+ failPage("2");
604
+ await act(() => result.current.fetchNextPage());
605
+ expect(result.current.isFetchNextPageError).toBe(true);
606
+
607
+ await act(() => result.current.refetch());
608
+
609
+ expect(result.current.isFetchNextPageError).toBe(false);
610
+ expect(result.current.error).toBeNull();
611
+ });
612
+
613
+ it("should clear isFetchPreviousPageError after a successful refetch", async () => {
614
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)));
615
+ const { result } = renderHook(() =>
616
+ useInfiniteFetch(createPosts().setQueryParams({ page: 2 }), { pagination, dependencyTracking: false }),
617
+ );
618
+ await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
619
+ failPage("1");
620
+ await act(() => result.current.fetchPreviousPage());
621
+ expect(result.current.isFetchPreviousPageError).toBe(true);
622
+
623
+ await act(() => result.current.refetch());
624
+
625
+ expect(result.current.isFetchPreviousPageError).toBe(false);
626
+ });
627
+
628
+ it("should report only the direction of the last fetch", async () => {
629
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)));
630
+ const { result } = renderHook(() =>
631
+ useInfiniteFetch(createPosts().setQueryParams({ page: 2 }), { pagination, dependencyTracking: false }),
632
+ );
633
+ await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
634
+ mockList("/posts", () => failure());
635
+
636
+ await act(() => result.current.fetchNextPage());
637
+ expect(result.current.isFetchNextPageError).toBe(true);
638
+
639
+ await act(() => result.current.fetchPreviousPage());
640
+
641
+ expect(result.current.isFetchPreviousPageError).toBe(true);
642
+ expect(result.current.isFetchNextPageError).toBe(false);
643
+ });
644
+
645
+ it("should clear the flag of the other direction after it loads a page", async () => {
646
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)));
647
+ const { result } = renderHook(() =>
648
+ useInfiniteFetch(createPosts().setQueryParams({ page: 2 }), { pagination, dependencyTracking: false }),
649
+ );
650
+ await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
651
+ failPage("3");
652
+ await act(() => result.current.fetchNextPage());
653
+ expect(result.current.isFetchNextPageError).toBe(true);
654
+
655
+ await act(() => result.current.fetchPreviousPage());
656
+
657
+ expect(result.current.isFetchNextPageError).toBe(false);
658
+ expect(result.current.isFetchPreviousPageError).toBe(false);
659
+ });
660
+
661
+ it("should not set a direction flag when the refetch fails", async () => {
662
+ const { result } = await renderPosts();
663
+ failPage("2");
664
+ await act(() => result.current.fetchNextPage());
665
+ mockList("/posts", () => failure());
666
+
667
+ await act(() => result.current.refetch());
668
+
669
+ expect(result.current.error).not.toBeNull();
670
+ expect(result.current.isFetchNextPageError).toBe(false);
671
+ expect(result.current.isFetchPreviousPageError).toBe(false);
672
+ });
673
+ });
674
+
675
+ describe("rendering", () => {
676
+ it("should show the current value of a field read for the first time in a later render", async () => {
677
+ mockList("/posts", ({ query }) => (query.page === "2" ? failure() : pageItems(Number(query.page))));
678
+ let renders = 0;
679
+ let pending: Promise<unknown> = Promise.resolve();
680
+
681
+ const Component = () => {
682
+ renders += 1;
683
+ const [hasDetails, setHasDetails] = useState(false);
684
+ const list = useInfiniteFetch(createPosts(), { pagination });
685
+ return (
686
+ <div>
687
+ <span>{`items: ${list.items.length}`}</span>
688
+ {hasDetails && <span>{list.isFetchNextPageError ? "failed" : "fine"}</span>}
689
+ <button
690
+ type="button"
691
+ onClick={() => {
692
+ pending = list.fetchNextPage();
693
+ }}
694
+ >
695
+ more
696
+ </button>
697
+ <button type="button" onClick={() => setHasDetails(true)}>
698
+ details
699
+ </button>
700
+ </div>
701
+ );
702
+ };
703
+
704
+ render(<Component />);
705
+ await screen.findByText("items: 2");
706
+ const rendersAfterLoad = renders;
707
+
708
+ act(() => screen.getByText("more").click());
709
+ await act(async () => {
710
+ await pending;
711
+ });
712
+
713
+ // The failed page changed only the values this component does not read
714
+ expect(renders).toBe(rendersAfterLoad);
715
+
716
+ act(() => screen.getByText("details").click());
717
+
718
+ expect(screen.getByText("failed")).toBeInTheDocument();
719
+ });
720
+ });
721
+
722
+ describe("boundaries", () => {
723
+ it("should suspend on mount and keep the previous list on screen for the next one", async () => {
724
+ const gate = createDeferred();
725
+ mockList("/posts", async ({ query }) => {
726
+ if (query.search === "b") {
727
+ await gate.promise;
728
+ }
729
+ return pageItems(Number(query.page));
730
+ });
731
+ const List = ({ search }: { search: string }) => {
732
+ const { items, isPreviousData } = useInfiniteFetch(createPosts().setQueryParams({ search }), {
733
+ pagination,
734
+ suspense: true,
735
+ keepPreviousData: "preserve",
736
+ });
737
+ return <div>{`items:${items.length} previous:${String(isPreviousData)}`}</div>;
738
+ };
739
+ const App = ({ search }: { search: string }) => (
740
+ <Suspense fallback="loading">
741
+ <List search={search} />
742
+ </Suspense>
743
+ );
744
+
745
+ const { rerender } = render(<App search="a" />);
746
+
747
+ expect(screen.getByText("loading")).toBeInTheDocument();
748
+ await screen.findByText("items:2 previous:false");
749
+
750
+ rerender(<App search="b" />);
751
+
752
+ expect(screen.queryByText("loading")).not.toBeInTheDocument();
753
+ expect(screen.getByText("items:2 previous:true")).toBeInTheDocument();
754
+
755
+ gate.resolve();
756
+ await screen.findByText("items:2 previous:false");
757
+ expect(calls.map((call) => call.query.search)).toEqual(["a", "b"]);
758
+ });
759
+
760
+ it("should render the loading state on the server without sending requests", () => {
761
+ const server = new Client({ url: baseUrl, mode: "server" });
762
+ const add = vi.spyOn(server.fetchDispatcher, "add");
763
+ const List = ({ suspense }: { suspense: boolean }) => {
764
+ const { items, loading, hasNextPage } = useInfiniteFetch(
765
+ server.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({ endpoint: "/posts" }),
766
+ { pagination, suspense },
767
+ );
768
+ return <div>{loading ? "loading" : `items:${items.length} next:${String(hasNextPage)}`}</div>;
769
+ };
770
+
771
+ expect(renderToString(<List suspense={false} />)).toContain("loading");
772
+ expect(renderToString(<List suspense />)).toContain("loading");
773
+ expect(add).not.toHaveBeenCalled();
774
+ });
775
+ });
776
+
777
+ describe("network", () => {
778
+ it("should load a page asked for while offline once the network is back", async () => {
779
+ const { result } = await renderPosts();
780
+
781
+ act(() => client.appManager.setOnline(false));
782
+ let pending: Promise<unknown> = Promise.resolve();
783
+ act(() => {
784
+ pending = result.current.fetchNextPage();
785
+ });
786
+
787
+ expect(result.current.isFetchingNextPage).toBe(true);
788
+ expect(result.current.error).toBeNull();
789
+
790
+ act(() => client.appManager.setOnline(true));
791
+ await act(async () => {
792
+ await pending;
793
+ });
794
+
795
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
796
+ expect(result.current.error).toBeNull();
797
+ expect(result.current.isFetchNextPageError).toBe(false);
798
+ expect(pagesOf("2")).toHaveLength(1);
799
+ });
800
+ });
801
+
802
+ describe("disabled lists", () => {
803
+ // Invalidation is handled in a microtask, so many keys end up in one refetch
804
+ const invalidate = async () => {
805
+ await act(async () => {
806
+ client.cache.invalidate();
807
+ await Promise.resolve();
808
+ });
809
+ };
810
+
811
+ const loadPages = async () => {
812
+ const first = await renderPosts(2);
813
+ first.unmount();
814
+ return vi.spyOn(client.fetchDispatcher, "add");
815
+ };
816
+
817
+ it("should not refetch a disabled list when its pages are invalidated", async () => {
818
+ const add = await loadPages();
819
+ const { result } = renderHook(() =>
820
+ useInfiniteFetch(createPosts(), { pagination, disabled: true, dependencyTracking: false }),
821
+ );
822
+ expect(result.current.pageParams).toEqual([1, 2]);
823
+
824
+ await invalidate();
825
+
826
+ expect(add).not.toHaveBeenCalled();
827
+ expect(result.current.isFetching).toBe(false);
828
+ });
829
+
830
+ it("should not refetch a list disabled after loading when its pages are invalidated", async () => {
831
+ const { result, rerender } = renderHook(
832
+ ({ disabled }) => useInfiniteFetch(createPosts(), { pagination, disabled, dependencyTracking: false }),
833
+ { initialProps: { disabled: false } },
834
+ );
835
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
836
+ const add = vi.spyOn(client.fetchDispatcher, "add");
837
+
838
+ rerender({ disabled: true });
839
+ await invalidate();
840
+
841
+ expect(add).not.toHaveBeenCalled();
842
+ expect(result.current.isFetching).toBe(false);
843
+
844
+ rerender({ disabled: false });
845
+
846
+ expect(result.current.isRefetching).toBe(true);
847
+ await waitFor(() => expect(result.current.isRefetching).toBe(false));
848
+ expect(add).toHaveBeenCalledTimes(1);
849
+ });
850
+
851
+ it("should refetch invalidated pages for the enabled hook of a list shared with a disabled one", async () => {
852
+ const add = await loadPages();
853
+ const disabled = renderHook(() =>
854
+ useInfiniteFetch(createPosts(), { pagination, disabled: true, dependencyTracking: false }),
855
+ );
856
+ const enabled = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
857
+ mockList("/posts", ({ query }) => pageItems(Number(query.page)).map((post) => ({ ...post, version: 2 })));
858
+
859
+ await invalidate();
860
+
861
+ await waitFor(() => expect(enabled.result.current.items.map((post) => post.version)).toEqual([2, 2, 2, 2]));
862
+ expect(disabled.result.current.items.map((post) => post.version)).toEqual([2, 2, 2, 2]);
863
+ expect(add).toHaveBeenCalledTimes(2);
864
+
865
+ enabled.unmount();
866
+ await invalidate();
867
+
868
+ expect(add).toHaveBeenCalledTimes(2);
869
+ });
870
+ });
871
+
872
+ describe("lifecycle", () => {
873
+ it("should leave no listeners behind after unmounting mid-fetch", async () => {
874
+ const listeners = countListeners(client);
875
+ const { result, unmount } = await renderPosts();
876
+ const gate = createDeferred();
877
+ mockList("/posts", async ({ query }) => {
878
+ await gate.promise;
879
+ return pageItems(Number(query.page));
880
+ });
881
+
882
+ act(() => {
883
+ result.current.fetchNextPage();
884
+ result.current.refetch();
885
+ });
886
+ await waitFor(() => expect(calls).toHaveLength(2));
887
+ unmount();
888
+ gate.resolve();
889
+
890
+ await waitFor(() => expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(0));
891
+ await waitFor(() => expect(countListeners(client)).toEqual(listeners));
892
+ });
893
+
894
+ it("should send every page once in StrictMode", async () => {
895
+ const listeners = countListeners(client);
896
+ const onSuccess = vi.fn();
897
+ const { result, unmount } = renderHook(
898
+ () => {
899
+ const list = useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false });
900
+ list.onSuccess(onSuccess);
901
+ return list;
902
+ },
903
+ { wrapper: StrictMode },
904
+ );
905
+ await waitFor(() => expect(result.current.pageParams).toEqual([1]));
906
+ expect(calls).toHaveLength(1);
907
+
908
+ await act(() => result.current.fetchNextPage());
909
+ expect(calls).toHaveLength(2);
910
+
911
+ await act(() => result.current.refetch());
912
+ expect(calls).toHaveLength(4);
913
+
914
+ act(() => {
915
+ client.cache.invalidate(createPosts().setQueryParams({ page: 1 }));
916
+ });
917
+ await waitFor(() => expect(calls).toHaveLength(6));
918
+ await waitFor(() => expect(result.current.isFetching).toBe(false));
919
+
920
+ expect(calls).toHaveLength(6);
921
+ expect(onSuccess).toHaveBeenCalledTimes(6);
922
+ expect(result.current.pageParams).toEqual([1, 2]);
923
+
924
+ unmount();
925
+ expect(countListeners(client)).toEqual(listeners);
926
+ });
927
+
928
+ it("should fetch once when enabled, disabled and enabled again", async () => {
929
+ const add = vi.spyOn(client.fetchDispatcher, "add");
930
+ const { result, rerender } = renderHook(
931
+ ({ disabled }) => useInfiniteFetch(createPosts(), { pagination, disabled, dependencyTracking: false }),
932
+ { initialProps: { disabled: false } },
933
+ );
934
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
935
+
936
+ rerender({ disabled: true });
937
+ expect(ids(result.current.items)).toEqual([1, 2]);
938
+ expect(result.current.loading).toBe(false);
939
+ rerender({ disabled: false });
940
+
941
+ expect(result.current.isFetching).toBe(false);
942
+ expect(add).toHaveBeenCalledTimes(1);
943
+ });
944
+
945
+ it("should show the cached pages of a disabled list without refetching them", async () => {
946
+ const stale = () => createPosts().setStaleTime(0);
947
+ const first = renderHook(() => useInfiniteFetch(stale(), { pagination, dependencyTracking: false }));
948
+ await waitFor(() => expect(first.result.current.items).toHaveLength(2));
949
+ await act(() => first.result.current.fetchNextPage());
950
+ first.unmount();
951
+ await waitForStalePages(stale());
952
+ const add = vi.spyOn(client.fetchDispatcher, "add");
953
+
954
+ const { result, rerender } = renderHook(
955
+ ({ disabled }) => useInfiniteFetch(stale(), { pagination, disabled, dependencyTracking: false }),
956
+ { initialProps: { disabled: true } },
957
+ );
958
+
959
+ expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
960
+ expect(result.current.loading).toBe(false);
961
+ expect(result.current.isFetching).toBe(false);
962
+ expect(add).not.toHaveBeenCalled();
963
+
964
+ rerender({ disabled: false });
965
+
966
+ expect(result.current.isRefetching).toBe(true);
967
+ await waitFor(() => expect(result.current.isRefetching).toBe(false));
968
+ expect(add).toHaveBeenCalledTimes(2);
969
+ });
970
+
971
+ it("should not fetch a filter left for a loaded one while it was bounced", async () => {
972
+ const { result, rerender } = renderHook(
973
+ ({ search }) =>
974
+ useInfiniteFetch(createPosts().setQueryParams({ search }), {
975
+ pagination,
976
+ bounce: true,
977
+ bounceTime: 30,
978
+ dependencyTracking: false,
979
+ }),
980
+ { initialProps: { search: "a" } },
981
+ );
982
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
983
+ const add = vi.spyOn(client.fetchDispatcher, "add");
984
+
985
+ rerender({ search: "ab" });
986
+ rerender({ search: "a" });
987
+
988
+ expect(result.current.bounce.active).toBe(true);
989
+ expect(ids(result.current.items)).toEqual([1, 2]);
990
+ await waitFor(() => expect(result.current.bounce.active).toBe(false));
991
+
992
+ expect(add).not.toHaveBeenCalled();
993
+ expect(result.current.isFetching).toBe(false);
994
+ });
995
+
996
+ it("should not fetch a bounced filter of a list disabled in the meantime", async () => {
997
+ const { result, rerender } = renderHook(
998
+ ({ search, disabled }) =>
999
+ useInfiniteFetch(createPosts().setQueryParams({ search }), {
1000
+ pagination,
1001
+ disabled,
1002
+ bounce: true,
1003
+ bounceTime: 30,
1004
+ dependencyTracking: false,
1005
+ }),
1006
+ { initialProps: { search: "a", disabled: false } },
1007
+ );
1008
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
1009
+ const add = vi.spyOn(client.fetchDispatcher, "add");
1010
+
1011
+ rerender({ search: "ab", disabled: false });
1012
+ rerender({ search: "ab", disabled: true });
1013
+
1014
+ expect(result.current.bounce.active).toBe(true);
1015
+ await waitFor(() => expect(result.current.bounce.active).toBe(false));
1016
+
1017
+ expect(add).not.toHaveBeenCalled();
1018
+ expect(result.current.isFetching).toBe(false);
1019
+
1020
+ rerender({ search: "ab", disabled: false });
1021
+
1022
+ await waitFor(() => expect(result.current.isPreviousData).toBe(false));
1023
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
1024
+ expect(add).toHaveBeenCalledTimes(1);
1025
+ });
1026
+ });
1027
+ });