@hyper-fetch/react 9.5.2 → 9.6.1

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 (58) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  3. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  4. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  5. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  6. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
  7. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
  8. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
  9. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
  10. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
  11. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
  12. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
  13. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
  14. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  15. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  16. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  17. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +2 -1
  18. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  19. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +311 -0
  20. package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
  21. package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
  22. package/__tests__/utils/use-queue.utils.ts +8 -4
  23. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  24. package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
  25. package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
  26. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
  27. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
  28. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
  29. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
  30. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
  31. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
  32. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
  33. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
  34. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
  35. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
  36. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
  37. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
  38. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
  39. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
  40. package/dist/index.d.ts +1 -0
  41. package/dist/index.d.ts.map +1 -1
  42. package/dist/index.mjs +917 -3
  43. package/dist/index.mjs.map +1 -1
  44. package/dist/provider/provider.types.d.ts +2 -0
  45. package/dist/provider/provider.types.d.ts.map +1 -1
  46. package/package.json +1 -1
  47. package/src/helpers/use-request-events/use-request-events.hooks.ts +17 -5
  48. package/src/hooks/use-infinite-fetch/index.ts +3 -0
  49. package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
  50. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
  51. package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
  52. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
  53. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
  54. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
  55. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
  56. package/src/index.ts +1 -0
  57. package/src/provider/provider.types.ts +3 -0
  58. package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
@@ -0,0 +1,353 @@
1
+ import { Client } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
4
+
5
+ import {
6
+ baseUrl,
7
+ createDeferred,
8
+ createListServer,
9
+ pageItems,
10
+ settleRequests,
11
+ } from "../../utils/use-infinite-fetch.utils";
12
+
13
+ const { startServer, stopServer, resetMocks, mockList, calls, resetCalls } = createListServer();
14
+
15
+ type Post = { id: number; search?: string };
16
+ type Query = { page?: number; limit?: number; search?: string; sort?: string };
17
+
18
+ const ids = (items: Post[]) => items.map((item) => item.id);
19
+
20
+ describe("useInfiniteFetch [ Start over ]", () => {
21
+ let client: Client;
22
+
23
+ const createPosts = () => client.createRequest<{ response: Post[]; queryParams: Query }>()({ endpoint: "/posts" });
24
+
25
+ const mockPosts = () => {
26
+ mockList("/posts", ({ query }) => {
27
+ return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
28
+ });
29
+ };
30
+
31
+ const renderList = (initialQuery: Query, options: Record<string, unknown> = {}) => {
32
+ return renderHook(
33
+ ({ query }: { query: Query }) =>
34
+ useInfiniteFetch(createPosts().setQueryParams(query), {
35
+ pagination: { page: "page", limit: "limit" },
36
+ dependencyTracking: false,
37
+ ...options,
38
+ }),
39
+ { initialProps: { query: initialQuery } },
40
+ );
41
+ };
42
+
43
+ beforeAll(() => startServer());
44
+ afterAll(() => stopServer());
45
+
46
+ beforeEach(() => {
47
+ client = new Client({ url: baseUrl });
48
+ resetCalls();
49
+ mockPosts();
50
+ });
51
+
52
+ afterEach(async () => {
53
+ await settleRequests(client);
54
+ resetMocks();
55
+ });
56
+
57
+ it.each<[string, Query, Query]>([
58
+ ["a filter", { search: "a" }, { search: "b" }],
59
+ ["the sort", { sort: "asc" }, { sort: "desc" }],
60
+ ["the page size", { limit: 2 }, { limit: 3 }],
61
+ ])("should start a new list when %s changes", async (_name, before, after) => {
62
+ const { result, rerender } = renderList(before);
63
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
64
+ await act(() => result.current.fetchNextPage());
65
+ expect(result.current.pageParams).toEqual([1, 2]);
66
+ resetCalls();
67
+
68
+ rerender({ query: after });
69
+
70
+ await waitFor(() => expect(result.current.isPreviousData).toBe(false));
71
+ await waitFor(() => expect(result.current.pageParams).toEqual([1]));
72
+ expect(calls).toHaveLength(1);
73
+ expect(calls[0].query.page).toBe("1");
74
+ });
75
+
76
+ it("should start a new list when a URL param changes", async () => {
77
+ mockList("/users/:userId/posts", ({ path }) => [{ id: Number(path.split("/")[2]) }]);
78
+ const request = client.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({
79
+ endpoint: "/users/:userId/posts",
80
+ });
81
+
82
+ const { result, rerender } = renderHook(
83
+ ({ userId }) =>
84
+ useInfiniteFetch(request.setParams({ userId }), { pagination: { page: "page" }, dependencyTracking: false }),
85
+ { initialProps: { userId: 1 } },
86
+ );
87
+ await waitFor(() => expect(ids(result.current.items)).toEqual([1]));
88
+
89
+ rerender({ userId: 2 });
90
+
91
+ // Another resource - the list of the previous user is not shown in the meantime
92
+ expect(result.current.items).toEqual([]);
93
+ expect(result.current.loading).toBe(true);
94
+ await waitFor(() => expect(ids(result.current.items)).toEqual([2]));
95
+ });
96
+
97
+ it("should start at the new page when the parent changes the paging field", async () => {
98
+ const { result, rerender } = renderList({ page: 5 });
99
+ await waitFor(() => expect(result.current.pageParams).toEqual([5]));
100
+
101
+ rerender({ query: { page: 9 } });
102
+
103
+ await waitFor(() => expect(result.current.pageParams).toEqual([9]));
104
+ expect(calls.map((call) => call.query.page)).toEqual(["5", "9"]);
105
+ });
106
+
107
+ it("should restore every page of a filter used before without requests", async () => {
108
+ const { result, rerender } = renderList({ search: "a" });
109
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
110
+ await act(() => result.current.fetchNextPage());
111
+
112
+ rerender({ query: { search: "b" } });
113
+ await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
114
+ resetCalls();
115
+
116
+ rerender({ query: { search: "a" } });
117
+
118
+ expect(result.current.pageParams).toEqual([1, 2]);
119
+ expect(result.current.items.map((item) => item.search)).toEqual(["a", "a", "a", "a"]);
120
+ expect(result.current.isPreviousData).toBe(false);
121
+ await new Promise((resolve) => {
122
+ setTimeout(resolve, 30);
123
+ });
124
+ expect(calls).toHaveLength(0);
125
+ });
126
+
127
+ it("should refresh a restored filter once its pages are stale", async () => {
128
+ const request = createPosts().setStaleTime(0);
129
+ const { result, rerender } = renderHook(
130
+ ({ search }) =>
131
+ useInfiniteFetch(request.setQueryParams({ search }), {
132
+ pagination: { page: "page" },
133
+ dependencyTracking: false,
134
+ }),
135
+ { initialProps: { search: "a" } },
136
+ );
137
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
138
+
139
+ rerender({ search: "b" });
140
+ await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
141
+ await new Promise((resolve) => {
142
+ setTimeout(resolve, 5);
143
+ });
144
+ resetCalls();
145
+
146
+ rerender({ search: "a" });
147
+
148
+ expect(result.current.items[0]?.search).toBe("a");
149
+ await waitFor(() => expect(calls).toHaveLength(1));
150
+ });
151
+
152
+ it("should drop to the starting page on reset and fetch it again", async () => {
153
+ const onReset = vi.fn();
154
+ const { result } = renderHook(() => {
155
+ const list = useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false });
156
+ list.onReset(onReset);
157
+ return list;
158
+ });
159
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
160
+ await act(() => result.current.fetchNextPage());
161
+ resetCalls();
162
+
163
+ await act(() => result.current.reset());
164
+
165
+ expect(result.current.pageParams).toEqual([1]);
166
+ expect(calls.map((call) => call.query.page)).toEqual(["1"]);
167
+ expect(onReset).toHaveBeenCalledTimes(1);
168
+ });
169
+
170
+ it("should report a new list through onReset", async () => {
171
+ const onReset = vi.fn();
172
+ const { result, rerender } = renderHook(
173
+ ({ search }) => {
174
+ const list = useInfiniteFetch(createPosts().setQueryParams({ search }), {
175
+ pagination: { page: "page" },
176
+ dependencyTracking: false,
177
+ });
178
+ list.onReset(onReset);
179
+ return list;
180
+ },
181
+ { initialProps: { search: "a" } },
182
+ );
183
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
184
+ expect(onReset).not.toHaveBeenCalled();
185
+
186
+ rerender({ search: "b" });
187
+
188
+ expect(onReset).toHaveBeenCalledTimes(1);
189
+ });
190
+
191
+ describe("late responses", () => {
192
+ it("should not let a late page of the old filter into the new list", async () => {
193
+ const gate = createDeferred();
194
+ mockList("/posts", async ({ query }) => {
195
+ if (query.search === "old") {
196
+ await gate.promise;
197
+ }
198
+ return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
199
+ });
200
+
201
+ const { result, rerender } = renderList({ search: "old" });
202
+ await waitFor(() => expect(calls).toHaveLength(1));
203
+
204
+ rerender({ query: { search: "new" } });
205
+ await waitFor(() => expect(result.current.items[0]?.search).toBe("new"));
206
+
207
+ gate.resolve();
208
+ await new Promise((resolve) => {
209
+ setTimeout(resolve, 30);
210
+ });
211
+
212
+ expect(result.current.items.map((item) => item.search)).toEqual(["new", "new"]);
213
+ });
214
+
215
+ it("should cancel the page of the old filter", async () => {
216
+ const gate = createDeferred();
217
+ mockList("/posts", async ({ query }) => {
218
+ if (query.search === "old") {
219
+ await gate.promise;
220
+ }
221
+ return pageItems(1);
222
+ });
223
+
224
+ const { result, rerender } = renderList({ search: "old" });
225
+ await waitFor(() => expect(calls).toHaveLength(1));
226
+
227
+ rerender({ query: { search: "new" } });
228
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
229
+ gate.resolve();
230
+ await new Promise((resolve) => {
231
+ setTimeout(resolve, 30);
232
+ });
233
+
234
+ const oldPage = createPosts().setQueryParams({ search: "old", page: 1 });
235
+ expect(oldPage.read()).toBeUndefined();
236
+ });
237
+
238
+ it("should keep fetching a page another hook still needs", async () => {
239
+ const gate = createDeferred();
240
+ mockList("/posts", async () => {
241
+ await gate.promise;
242
+ return pageItems(1);
243
+ });
244
+
245
+ const stays = renderList({ search: "shared" });
246
+ const leaves = renderList({ search: "shared" });
247
+ await waitFor(() => expect(calls).toHaveLength(1));
248
+
249
+ leaves.rerender({ query: { search: "other" } });
250
+ gate.resolve();
251
+
252
+ await waitFor(() => expect(stays.result.current.items).toHaveLength(2));
253
+ });
254
+ });
255
+
256
+ describe("previous data", () => {
257
+ it("should keep the previous list on screen until the new one arrives", async () => {
258
+ const gate = createDeferred();
259
+ const { result, rerender } = renderList({ search: "a" });
260
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
261
+
262
+ mockList("/posts", async ({ query }) => {
263
+ await gate.promise;
264
+ return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
265
+ });
266
+ rerender({ query: { search: "b" } });
267
+
268
+ expect(result.current.isPreviousData).toBe(true);
269
+ expect(result.current.loading).toBe(false);
270
+ expect(result.current.isFetching).toBe(true);
271
+ expect(result.current.items[0].search).toBe("a");
272
+ expect(result.current.hasNextPage).toBe(false);
273
+
274
+ await act(async () => {
275
+ gate.resolve();
276
+ });
277
+
278
+ await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
279
+ expect(result.current.isPreviousData).toBe(false);
280
+ });
281
+
282
+ it("should clear the list right away in the clean mode", async () => {
283
+ const { result, rerender } = renderList({ search: "a" }, { keepPreviousData: "clean" });
284
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
285
+
286
+ rerender({ query: { search: "b" } });
287
+
288
+ expect(result.current.items).toEqual([]);
289
+ expect(result.current.isPreviousData).toBe(false);
290
+ expect(result.current.loading).toBe(true);
291
+ });
292
+
293
+ it("should keep the list of another resource in the preserve mode", async () => {
294
+ mockList("/users/:userId/posts", () => [{ id: 1 }]);
295
+ const request = client.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({
296
+ endpoint: "/users/:userId/posts",
297
+ });
298
+
299
+ const { result, rerender } = renderHook(
300
+ ({ userId }) =>
301
+ useInfiniteFetch(request.setParams({ userId }), {
302
+ pagination: { page: "page" },
303
+ keepPreviousData: "preserve",
304
+ dependencyTracking: false,
305
+ }),
306
+ { initialProps: { userId: 1 } },
307
+ );
308
+ await waitFor(() => expect(result.current.items).toHaveLength(1));
309
+
310
+ rerender({ userId: 2 });
311
+
312
+ expect(result.current.items).toHaveLength(1);
313
+ expect(result.current.isPreviousData).toBe(true);
314
+ });
315
+
316
+ it("should show the empty state when the new list fails", async () => {
317
+ const { result, rerender } = renderList({ search: "a" });
318
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
319
+
320
+ resetMocks();
321
+ mockList("/posts", () => ({ __failure: 500 }));
322
+ rerender({ query: { search: "b" } });
323
+
324
+ await waitFor(() => expect(result.current.error).toBeTruthy());
325
+ expect(result.current.items).toEqual([]);
326
+ expect(result.current.isPreviousData).toBe(false);
327
+ });
328
+ });
329
+
330
+ describe("bounce", () => {
331
+ it("should fetch only the settled filter", async () => {
332
+ const { result, rerender } = renderList({ search: "a" }, { bounce: true, bounceTime: 30 });
333
+ await waitFor(() => expect(result.current.items).toHaveLength(2));
334
+ resetCalls();
335
+ const add = vi.spyOn(client.fetchDispatcher, "add");
336
+
337
+ rerender({ query: { search: "ab" } });
338
+ rerender({ query: { search: "abc" } });
339
+ rerender({ query: { search: "abcd" } });
340
+
341
+ expect(add).not.toHaveBeenCalled();
342
+ await waitFor(() => expect(result.current.items[0]?.search).toBe("abcd"));
343
+ expect(add).toHaveBeenCalledTimes(1);
344
+ expect(calls.map((call) => call.query.search)).toEqual(["abcd"]);
345
+ });
346
+
347
+ it("should fetch the first page right away on mount", async () => {
348
+ renderList({ search: "a" }, { bounce: true, bounceTime: 5000 });
349
+
350
+ await waitFor(() => expect(calls).toHaveLength(1));
351
+ });
352
+ });
353
+ });
@@ -0,0 +1,128 @@
1
+ import type { Pagination } from "@hyper-fetch/core";
2
+ import { Client, fetchInfinite } from "@hyper-fetch/core";
3
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
4
+
5
+ type Post = { id: number; title: string };
6
+
7
+ const client = new Client({ url: "http://localhost:3000" });
8
+
9
+ const getPosts = client.createRequest<{
10
+ response: Post[];
11
+ queryParams: { page?: number; limit?: number; search?: string };
12
+ }>()({ endpoint: "/posts" });
13
+
14
+ const getFeed = client.createRequest<{
15
+ response: { data: Post[]; nextCursor: string | null; count: number; label: string };
16
+ queryParams: { cursor?: string; topic?: string };
17
+ }>()({ endpoint: "/feed" });
18
+
19
+ const getUsers = client.createRequest<{
20
+ response: { users: Post[]; total: number };
21
+ queryParams: { offset?: number; limit?: number };
22
+ }>()({ endpoint: "/users" });
23
+
24
+ // The hook is only type checked here, rendering it would send requests
25
+ const types = <T>(callback: () => T) => callback as unknown as T;
26
+
27
+ describe("useInfiniteFetch [ TypeScript ]", () => {
28
+ it("should infer the items of an array response", () => {
29
+ const list = types(() => useInfiniteFetch(getPosts, { pagination: { page: "page" } }));
30
+
31
+ expectTypeOf(list.items).toEqualTypeOf<Post[]>();
32
+ expectTypeOf(list.pages).toEqualTypeOf<Post[][]>();
33
+ });
34
+
35
+ it("should infer the items from a response field", () => {
36
+ const list = types(() =>
37
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor", items: "data" } }),
38
+ );
39
+
40
+ expectTypeOf(list.items).toEqualTypeOf<Post[]>();
41
+ });
42
+
43
+ it("should infer the items from a function", () => {
44
+ const list = types(() =>
45
+ useInfiniteFetch(getFeed, {
46
+ pagination: { cursor: "cursor", next: "nextCursor", items: ({ data }) => data.data.map((post) => post.title) },
47
+ }),
48
+ );
49
+
50
+ expectTypeOf(list.items).toEqualTypeOf<string[]>();
51
+ });
52
+
53
+ it("should type the context of the callbacks", () => {
54
+ types(() =>
55
+ useInfiniteFetch(getFeed, {
56
+ pagination: {
57
+ cursor: "cursor",
58
+ items: "data",
59
+ next: ({ data, pages }) => {
60
+ expectTypeOf(data.nextCursor).toEqualTypeOf<string | null>();
61
+ expectTypeOf(pages).toBeArray();
62
+ return data.nextCursor;
63
+ },
64
+ },
65
+ }),
66
+ );
67
+ });
68
+
69
+ it("should use the type returned from select", () => {
70
+ const list = types(() =>
71
+ useInfiniteFetch(getPosts, {
72
+ pagination: { page: "page" },
73
+ select: ({ items }) => items.length,
74
+ }),
75
+ );
76
+
77
+ expectTypeOf(list.items).toEqualTypeOf<number>();
78
+ });
79
+
80
+ it("should accept a reusable pagination", () => {
81
+ const pagination = { offset: "offset", limit: "limit", items: "users", total: "total" } satisfies Pagination<
82
+ typeof getUsers
83
+ >;
84
+ const list = types(() => useInfiniteFetch(getUsers, { pagination }));
85
+
86
+ expectTypeOf(list.items).toEqualTypeOf<Post[]>();
87
+ expectTypeOf(list.total).toEqualTypeOf<number | null>();
88
+ });
89
+
90
+ it("should type the prefetched items", () => {
91
+ const result = types(() => fetchInfinite(getPosts, { pagination: { page: "page" } }));
92
+
93
+ expectTypeOf(result).resolves.toHaveProperty("items").toEqualTypeOf<Post[]>();
94
+ });
95
+
96
+ it("should reject a wrong pagination", () => {
97
+ types(() => {
98
+ // @ts-expect-error pagination is required
99
+ useInfiniteFetch(getPosts, {});
100
+ // @ts-expect-error not a query param of the request
101
+ useInfiniteFetch(getPosts, { pagination: { page: "pageNumber" } });
102
+ // @ts-expect-error the page has to be a number
103
+ useInfiniteFetch(getPosts, { pagination: { page: "search" } });
104
+ // @ts-expect-error the limit has to be a number
105
+ useInfiniteFetch(getPosts, { pagination: { page: "page", limit: "search" } });
106
+ // @ts-expect-error offset pagination needs the limit
107
+ useInfiniteFetch(getUsers, { pagination: { offset: "offset", items: "users" } });
108
+ // @ts-expect-error cursor pagination needs the next cursor
109
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", items: "data" } });
110
+ // @ts-expect-error not a response field
111
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nope", items: "data" } });
112
+ // @ts-expect-error the next cursor cannot be a list
113
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "data", items: "data" } });
114
+ // @ts-expect-error items are required when the response is not an array
115
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor" } });
116
+ // @ts-expect-error items have to be an array field
117
+ useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor", items: "label" } });
118
+ useInfiniteFetch(getFeed, {
119
+ // @ts-expect-error total has to be a number field
120
+ pagination: { cursor: "cursor", next: "nextCursor", items: "data", total: "label" },
121
+ });
122
+ // @ts-expect-error modes cannot be mixed
123
+ useInfiniteFetch(getPosts, { pagination: { page: "page", offset: "limit" } });
124
+ // @ts-expect-error not a field of the item
125
+ useInfiniteFetch(getPosts, { pagination: { page: "page" }, uniqueBy: "nope" });
126
+ });
127
+ });
128
+ });
@@ -12,6 +12,7 @@ describe("useIsFetching [ Base ]", () => {
12
12
  });
13
13
 
14
14
  afterEach(() => {
15
+ vi.useRealTimers();
15
16
  resetMocks();
16
17
  });
17
18
 
@@ -25,10 +26,13 @@ describe("useIsFetching [ Base ]", () => {
25
26
  });
26
27
 
27
28
  it("should count the running fetch requests", async () => {
29
+ // The mock delays run on a fake clock, so each request settles only when the test moves time past it.
30
+ // On real timers a stall can settle both requests before the single running one is ever observed.
31
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
28
32
  const usersRequest = createRequest({ endpoint: "/users" });
29
33
  const postsRequest = createRequest({ endpoint: "/posts" });
30
34
  mockRequest(usersRequest, { delay: 30 });
31
- mockRequest(postsRequest, { delay: 60 });
35
+ mockRequest(postsRequest, { delay: 1000 });
32
36
 
33
37
  const { result } = renderHook(() => useIsFetching(client));
34
38
  expect(result.current).toBe(0);
@@ -37,14 +41,20 @@ describe("useIsFetching [ Base ]", () => {
37
41
  client.fetchDispatcher.add(usersRequest);
38
42
  client.fetchDispatcher.add(postsRequest);
39
43
  });
40
-
41
- await waitFor(() => {
42
- expect(result.current).toBe(2);
43
- });
44
- await waitFor(() => {
45
- expect(result.current).toBe(1);
46
- });
47
- await waitFor(() => {
44
+ expect(result.current).toBe(2);
45
+
46
+ // Small clock steps per real-timer poll: the users response gets real ticks to settle long before
47
+ // the clock can reach the posts delay, wherever msw registers its delay timers
48
+ await vi.waitFor(
49
+ async () => {
50
+ await act(() => vi.advanceTimersByTimeAsync(5));
51
+ expect(result.current).toBe(1);
52
+ },
53
+ { interval: 5 },
54
+ );
55
+
56
+ await act(() => vi.advanceTimersByTimeAsync(1000));
57
+ await vi.waitFor(() => {
48
58
  expect(result.current).toBe(0);
49
59
  });
50
60
  });
@@ -45,7 +45,8 @@ describe("useSubmit [ Concurrency ]", () => {
45
45
  await testSuccessState(mock, responseTwo);
46
46
  });
47
47
  it("should start in loading mode when another request is ongoing", async () => {
48
- mockRequest(request);
48
+ // The default 20ms mock can resolve during the render pause below, so keep the request in flight explicitly
49
+ mockRequest(request, { delay: 1000 });
49
50
  const responseOne = renderUseSubmit(request);
50
51
 
51
52
  act(() => {