@hyper-fetch/react 9.5.2 → 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 (47) hide show
  1. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
  2. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
  3. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
  4. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
  5. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
  6. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
  7. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
  8. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
  9. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +310 -0
  10. package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
  11. package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
  12. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  13. package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
  14. package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
  15. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
  16. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
  17. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
  18. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
  19. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
  20. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
  21. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
  22. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
  23. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
  24. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
  25. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
  26. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
  27. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
  28. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
  29. package/dist/index.d.ts +1 -0
  30. package/dist/index.d.ts.map +1 -1
  31. package/dist/index.mjs +914 -2
  32. package/dist/index.mjs.map +1 -1
  33. package/dist/provider/provider.types.d.ts +2 -0
  34. package/dist/provider/provider.types.d.ts.map +1 -1
  35. package/package.json +1 -1
  36. package/src/helpers/use-request-events/use-request-events.hooks.ts +11 -1
  37. package/src/hooks/use-infinite-fetch/index.ts +3 -0
  38. package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
  39. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
  40. package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
  41. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
  42. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
  43. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
  44. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
  45. package/src/index.ts +1 -0
  46. package/src/provider/provider.types.ts +3 -0
  47. package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
@@ -0,0 +1,310 @@
1
+ import type { OptimisticCallbackResult, OptimisticRollbackArgs, RequestInstance } from "@hyper-fetch/core";
2
+ import { Client, scopeKey } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+ import { act, renderHook, waitFor } from "@testing-library/react";
5
+ import { useSubmit } from "hooks/use-submit";
6
+ import { StrictMode } from "react";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ type Emitter = Client["requestManager"]["emitter"];
11
+
12
+ /**
13
+ * Sums the listeners of all events, optionally only of the ones scoped to given request id
14
+ */
15
+ const countListeners = (emitter: Emitter, requestId = "") => {
16
+ return emitter
17
+ .eventNames()
18
+ .filter((name) => String(name).includes(requestId))
19
+ .reduce((sum, name) => sum + emitter.listenerCount(name), 0);
20
+ };
21
+
22
+ /**
23
+ * Builds isolated client with a mutation which is settled by the core
24
+ */
25
+ const createSetup = () => {
26
+ const client = new Client({ url: "shared-base-url" });
27
+ const list = client.createRequest<{ response: string[] }>()({ endpoint: "/list" });
28
+ const rollback = vi.fn((_args: OptimisticRollbackArgs<RequestInstance>) => undefined);
29
+ const invalidate = vi.spyOn(client.cache, "invalidate");
30
+
31
+ const mutation = client
32
+ .createRequest<{ response: { ok: boolean } }>()({ endpoint: "/mutation", method: "POST" })
33
+ .setOptimistic(() => ({ rollback, invalidate: [list] }));
34
+
35
+ const dispatcher = client.submitDispatcher;
36
+ const queryKey = scopeKey(mutation.queryKey, mutation.scope);
37
+ const abortKey = scopeKey(mutation.abortKey, mutation.scope);
38
+
39
+ return { client, list, mutation, rollback, invalidate, dispatcher, queryKey, abortKey };
40
+ };
41
+
42
+ type Setup = ReturnType<typeof createSetup>;
43
+
44
+ const createCallbacks = () => ({
45
+ onSubmitSuccess: vi.fn(),
46
+ onSubmitError: vi.fn(),
47
+ onSubmitFinished: vi.fn(),
48
+ onSubmitRequestStart: vi.fn(),
49
+ onSubmitResponseStart: vi.fn(),
50
+ onSubmitDownloadProgress: vi.fn(),
51
+ onSubmitUploadProgress: vi.fn(),
52
+ onSubmitOfflineError: vi.fn(),
53
+ onSubmitAbort: vi.fn(),
54
+ });
55
+
56
+ const expectNoCallbacks = (callbacks: ReturnType<typeof createCallbacks>) => {
57
+ Object.values(callbacks).forEach((callback) => {
58
+ expect(callback).not.toHaveBeenCalled();
59
+ });
60
+ };
61
+
62
+ /**
63
+ * Listeners the core itself keeps for a queued optimistic request sent without any hook
64
+ */
65
+ const measureCoreListeners = async () => {
66
+ const { client, mutation, dispatcher, queryKey, abortKey } = createSetup();
67
+ dispatcher.stop(queryKey);
68
+ let requestId = "";
69
+
70
+ const pending = mutation.send({
71
+ dispatcherType: "submit",
72
+ onBeforeSent: (data) => {
73
+ requestId = data.requestId;
74
+ },
75
+ });
76
+ await waitFor(() => {
77
+ expect(requestId).not.toBe("");
78
+ });
79
+ const count = countListeners(client.requestManager.emitter, requestId);
80
+
81
+ dispatcher.delete(queryKey, requestId, abortKey);
82
+ await pending;
83
+
84
+ return count;
85
+ };
86
+
87
+ const modes = [
88
+ { mode: "default", wrapper: undefined },
89
+ { mode: "StrictMode", wrapper: StrictMode },
90
+ ];
91
+
92
+ describe("useSubmit [ Unmount ]", () => {
93
+ beforeAll(() => {
94
+ startServer();
95
+ });
96
+
97
+ afterEach(() => {
98
+ resetMocks();
99
+ });
100
+
101
+ afterAll(() => {
102
+ stopServer();
103
+ });
104
+
105
+ describe.each(modes)("when rendered in $mode", ({ wrapper }) => {
106
+ const renderSubmit = <Request extends RequestInstance>(request: Request) => {
107
+ const callbacks = createCallbacks();
108
+ const view = renderHook(() => useSubmit(request), { wrapper });
109
+
110
+ act(() => {
111
+ view.result.current.onSubmitSuccess(callbacks.onSubmitSuccess);
112
+ view.result.current.onSubmitError(callbacks.onSubmitError);
113
+ view.result.current.onSubmitFinished(callbacks.onSubmitFinished);
114
+ view.result.current.onSubmitRequestStart(callbacks.onSubmitRequestStart);
115
+ view.result.current.onSubmitResponseStart(callbacks.onSubmitResponseStart);
116
+ view.result.current.onSubmitDownloadProgress(callbacks.onSubmitDownloadProgress);
117
+ view.result.current.onSubmitUploadProgress(callbacks.onSubmitUploadProgress);
118
+ view.result.current.onSubmitOfflineError(callbacks.onSubmitOfflineError);
119
+ view.result.current.onSubmitAbort(callbacks.onSubmitAbort);
120
+ });
121
+
122
+ return { ...view, callbacks };
123
+ };
124
+
125
+ /**
126
+ * Submits and unmounts in the same tick, so the optimistic callback is still being awaited by the core
127
+ */
128
+ const submitAndUnmount = async (setup: Setup) => {
129
+ const { result, unmount, callbacks } = renderSubmit(setup.mutation);
130
+ let requestId = "";
131
+ let pending: ReturnType<typeof result.current.submit> | undefined;
132
+
133
+ act(() => {
134
+ pending = result.current.submit({
135
+ onBeforeSent: (data: { requestId: string }) => {
136
+ requestId = data.requestId;
137
+ },
138
+ });
139
+ unmount();
140
+ });
141
+ await waitFor(() => {
142
+ expect(requestId).not.toBe("");
143
+ });
144
+
145
+ return { requestId, callbacks, pending: pending as NonNullable<typeof pending> };
146
+ };
147
+
148
+ const expectNoRequestListeners = async (setup: Setup, requestId: string) => {
149
+ await waitFor(() => {
150
+ expect(countListeners(setup.client.requestManager.emitter, requestId)).toBe(0);
151
+ });
152
+ };
153
+
154
+ describe("when unmounted in the same tick as submit", () => {
155
+ it("should not attach listeners for the pending request", async () => {
156
+ const coreListeners = await measureCoreListeners();
157
+ const setup = createSetup();
158
+ mockRequest(setup.mutation, { data: { ok: true } });
159
+ setup.dispatcher.stop(setup.queryKey);
160
+
161
+ const { requestId, pending } = await submitAndUnmount(setup);
162
+
163
+ expect(countListeners(setup.client.requestManager.emitter, requestId)).toBe(coreListeners);
164
+
165
+ setup.dispatcher.start(setup.queryKey);
166
+ await pending;
167
+ await expectNoRequestListeners(setup, requestId);
168
+ });
169
+
170
+ it("should invalidate once and fire no callback after success", async () => {
171
+ const setup = createSetup();
172
+ mockRequest(setup.mutation, { data: { ok: true } });
173
+
174
+ const { requestId, callbacks, pending } = await submitAndUnmount(setup);
175
+ const response = await pending;
176
+
177
+ expect(response.success).toBeTrue();
178
+ expectNoCallbacks(callbacks);
179
+ expect(setup.rollback).not.toHaveBeenCalled();
180
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
181
+ expect(setup.invalidate).toHaveBeenCalledWith(setup.list);
182
+ await expectNoRequestListeners(setup, requestId);
183
+ });
184
+
185
+ it("should roll back once and fire no callback after error", async () => {
186
+ const setup = createSetup();
187
+ mockRequest(setup.mutation, { status: 400 });
188
+
189
+ const { requestId, callbacks, pending } = await submitAndUnmount(setup);
190
+ const response = await pending;
191
+
192
+ expect(response.status).toBe(400);
193
+ expectNoCallbacks(callbacks);
194
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
195
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("error");
196
+ expect(setup.invalidate).not.toHaveBeenCalled();
197
+ await expectNoRequestListeners(setup, requestId);
198
+ });
199
+
200
+ it("should roll back once and fire no callback after abort", async () => {
201
+ const setup = createSetup();
202
+ mockRequest(setup.mutation, { data: { ok: true }, delay: 100 });
203
+
204
+ const { requestId, callbacks, pending } = await submitAndUnmount(setup);
205
+ await waitFor(() => {
206
+ expect(setup.dispatcher.getAllRunningRequests()).toHaveLength(1);
207
+ });
208
+ setup.mutation.abort();
209
+ await pending;
210
+
211
+ expectNoCallbacks(callbacks);
212
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
213
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("abort");
214
+ await expectNoRequestListeners(setup, requestId);
215
+ });
216
+
217
+ it("should roll back once when removed from the queue", async () => {
218
+ const setup = createSetup();
219
+ setup.dispatcher.stop(setup.queryKey);
220
+
221
+ const { requestId, callbacks, pending } = await submitAndUnmount(setup);
222
+ setup.dispatcher.delete(setup.queryKey, requestId, setup.abortKey);
223
+ await pending;
224
+
225
+ expectNoCallbacks(callbacks);
226
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
227
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("removed");
228
+ await expectNoRequestListeners(setup, requestId);
229
+ });
230
+
231
+ it("should fire no callback when the optimistic callback resolves after unmount", async () => {
232
+ const setup = createSetup();
233
+ let resolveOptimistic: (value: OptimisticCallbackResult<undefined>) => void = () => undefined;
234
+ const request = setup.mutation.setOptimistic(
235
+ () =>
236
+ new Promise<OptimisticCallbackResult<undefined>>((resolve) => {
237
+ resolveOptimistic = resolve;
238
+ }),
239
+ );
240
+ mockRequest(request, { status: 400 });
241
+ const { result, unmount, callbacks } = renderSubmit(request);
242
+ let pending: ReturnType<typeof result.current.submit> | undefined;
243
+
244
+ act(() => {
245
+ pending = result.current.submit();
246
+ });
247
+ unmount();
248
+ resolveOptimistic({ rollback: setup.rollback });
249
+ await pending;
250
+
251
+ expectNoCallbacks(callbacks);
252
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
253
+ });
254
+ });
255
+
256
+ describe("when submitted after unmount", () => {
257
+ it("should settle the request and leave no listeners behind", async () => {
258
+ const setup = createSetup();
259
+ mockRequest(setup.mutation, { status: 400 });
260
+ const requestListeners = countListeners(setup.client.requestManager.emitter);
261
+ const cacheListeners = countListeners(setup.client.cache.emitter);
262
+ const { result, unmount, callbacks } = renderSubmit(setup.mutation);
263
+
264
+ unmount();
265
+ const response = await result.current.submit();
266
+
267
+ expect(response.status).toBe(400);
268
+ expectNoCallbacks(callbacks);
269
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
270
+ await waitFor(() => {
271
+ expect(countListeners(setup.client.requestManager.emitter)).toBe(requestListeners);
272
+ });
273
+ expect(countListeners(setup.client.cache.emitter)).toBe(cacheListeners);
274
+ });
275
+ });
276
+
277
+ describe("when staying mounted", () => {
278
+ it("should keep delivering callbacks", async () => {
279
+ const setup = createSetup();
280
+ mockRequest(setup.mutation, { data: { ok: true } });
281
+ const { result, callbacks } = renderSubmit(setup.mutation);
282
+
283
+ await act(async () => {
284
+ await result.current.submit();
285
+ });
286
+
287
+ await waitFor(() => {
288
+ expect(callbacks.onSubmitSuccess).toHaveBeenCalledTimes(1);
289
+ });
290
+ expect(callbacks.onSubmitFinished).toHaveBeenCalledTimes(1);
291
+ expect(callbacks.onSubmitRequestStart).toHaveBeenCalledTimes(1);
292
+ expect(callbacks.onSubmitError).not.toHaveBeenCalled();
293
+ });
294
+
295
+ it("should keep receiving cache updates", async () => {
296
+ const setup = createSetup();
297
+ mockRequest(setup.mutation, { data: { ok: true } });
298
+ const { result } = renderHook(() => useSubmit(setup.mutation, { dependencyTracking: false }), { wrapper });
299
+
300
+ await act(async () => {
301
+ await result.current.submit();
302
+ });
303
+
304
+ await waitFor(() => {
305
+ expect(result.current.data).toStrictEqual({ ok: true });
306
+ });
307
+ });
308
+ });
309
+ });
310
+ });
@@ -0,0 +1,131 @@
1
+ import type { Client } from "@hyper-fetch/core";
2
+
3
+ import type { createDeferred, createListServer, ListCall } from "./use-infinite-fetch.utils";
4
+ import { failure } from "./use-infinite-fetch.utils";
5
+
6
+ export const pageSize = 2;
7
+
8
+ /**
9
+ * Simulated backend. Every paging style reads from the same list, so the same expectations hold for all of them.
10
+ */
11
+ export const createListBackend = () => ({
12
+ version: 1,
13
+ total: 6,
14
+ failing: new Set<number>(),
15
+ gate: null as ReturnType<typeof createDeferred<void>> | null,
16
+ });
17
+
18
+ export type ListBackend = ReturnType<typeof createListBackend>;
19
+
20
+ export type PagingMode = {
21
+ name: string;
22
+ /** Request starting from the first page */
23
+ create: (client: Client) => any;
24
+ /** Request starting from the given page, counted from 1 */
25
+ at: (client: Client, page: number) => any;
26
+ pagination: any;
27
+ /** Position of the first item requested by the call */
28
+ startOf: (call: ListCall) => number;
29
+ mock: (server: ReturnType<typeof createListServer>, backend: ListBackend) => void;
30
+ };
31
+
32
+ const respond = async (backend: ListBackend, start: number) => {
33
+ await backend.gate?.promise;
34
+
35
+ if (backend.failing.has(start)) {
36
+ return failure();
37
+ }
38
+
39
+ const end = Math.min(start + pageSize, backend.total);
40
+ const items = [];
41
+ for (let index = start; index < end; index += 1) {
42
+ items.push({ id: index + 1, version: backend.version });
43
+ }
44
+
45
+ return {
46
+ items,
47
+ total: backend.total,
48
+ next: end < backend.total ? String(end) : null,
49
+ previous: start > 0 ? String(Math.max(0, start - pageSize)) : null,
50
+ };
51
+ };
52
+
53
+ const fromPage = (page: unknown) => (Number(page) - 1) * pageSize;
54
+
55
+ const pageFields = { page: "page", limit: "limit", items: "items", total: "total" };
56
+
57
+ type Response = {
58
+ items: { id: number; version: number }[];
59
+ total: number;
60
+ next: string | null;
61
+ previous: string | null;
62
+ };
63
+
64
+ export const pagingModes: PagingMode[] = [
65
+ {
66
+ name: "page numbers",
67
+ create: (client) =>
68
+ client
69
+ .createRequest<{ response: Response; queryParams: any }>()({ endpoint: "/matrix/page" })
70
+ .setQueryParams({ limit: pageSize }),
71
+ at: (client, page) => pagingModes[0].create(client).setQueryParams({ limit: pageSize, page }),
72
+ pagination: pageFields,
73
+ startOf: (call) => fromPage(call.query.page),
74
+ mock: (server, backend) => {
75
+ server.mockList("/matrix/page", (call) => respond(backend, fromPage(call.query.page)));
76
+ },
77
+ },
78
+ {
79
+ name: "offsets",
80
+ create: (client) =>
81
+ client
82
+ .createRequest<{ response: Response; queryParams: any }>()({ endpoint: "/matrix/offset" })
83
+ .setQueryParams({ limit: pageSize }),
84
+ at: (client, page) => pagingModes[1].create(client).setQueryParams({ limit: pageSize, offset: fromPage(page) }),
85
+ pagination: { offset: "offset", limit: "limit", items: "items", total: "total" },
86
+ startOf: (call) => Number(call.query.offset),
87
+ mock: (server, backend) => {
88
+ server.mockList("/matrix/offset", (call) => respond(backend, Number(call.query.offset)));
89
+ },
90
+ },
91
+ {
92
+ name: "cursors",
93
+ create: (client) =>
94
+ client.createRequest<{ response: Response; queryParams: any }>()({ endpoint: "/matrix/cursor" }),
95
+ at: (client, page) => pagingModes[2].create(client).setQueryParams({ cursor: String(fromPage(page)) }),
96
+ pagination: { cursor: "cursor", next: "next", previous: "previous", items: "items", total: "total" },
97
+ startOf: (call) => Number(call.query.cursor ?? 0),
98
+ mock: (server, backend) => {
99
+ server.mockList("/matrix/cursor", (call) => respond(backend, Number(call.query.cursor ?? 0)));
100
+ },
101
+ },
102
+ {
103
+ name: "URL params",
104
+ create: (client) => pagingModes[3].at(client, 1),
105
+ at: (client, page) =>
106
+ client
107
+ .createRequest<{ response: Response }>()({ endpoint: "/matrix/params/:page/:limit" })
108
+ .setParams({ page, limit: pageSize } as any),
109
+ pagination: { ...pageFields, in: "params" },
110
+ startOf: (call) => fromPage(call.path.split("/")[3]),
111
+ mock: (server, backend) => {
112
+ server.mockList("/matrix/params/:page/:limit", (call) => respond(backend, fromPage(call.path.split("/")[3])));
113
+ },
114
+ },
115
+ {
116
+ name: "payload",
117
+ create: (client) => pagingModes[4].at(client, 1),
118
+ at: (client, page) =>
119
+ client
120
+ .createRequest<{ response: Response; payload: { page: number; limit: number } }>()({
121
+ endpoint: "/matrix/payload",
122
+ method: "POST",
123
+ })
124
+ .setPayload({ page, limit: pageSize }),
125
+ pagination: { ...pageFields, in: "payload" },
126
+ startOf: (call) => fromPage(call.body.page),
127
+ mock: (server, backend) => {
128
+ server.mockListPost("/matrix/payload", (call) => respond(backend, fromPage(call.body.page)));
129
+ },
130
+ },
131
+ ];
@@ -0,0 +1,90 @@
1
+ import type { Client } from "@hyper-fetch/core";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+ import { cleanup, configure, waitFor } from "@testing-library/react";
4
+ import { delay as wait, http, HttpResponse } from "msw";
5
+
6
+ // Responses travel through a mocked network - a busy machine can need more than the default second.
7
+ // This is only the limit of waiting, passing tests continue as soon as the condition is met.
8
+ configure({ asyncUtilTimeout: 5000 });
9
+ vi.setConfig({ testTimeout: 30_000 });
10
+
11
+ export const baseUrl = "http://localhost:3000";
12
+
13
+ export type ListCall = { path: string; query: Record<string, string>; body: any };
14
+
15
+ type ListResult = { status: number; data: unknown } | unknown;
16
+
17
+ export const failure = (status = 500) => ({ __failure: status });
18
+
19
+ const openGates = new Set<VoidFunction>();
20
+
21
+ export const createDeferred = <T = void>() => {
22
+ let resolve: (value: T) => void = () => null;
23
+ const promise = new Promise<T>((resolver) => {
24
+ resolve = resolver;
25
+ });
26
+ openGates.add(() => resolve(undefined as T));
27
+ return { promise, resolve };
28
+ };
29
+
30
+ /**
31
+ * Unmounting does not cancel requests. One still on its way could reach the server during the next test
32
+ * and be counted there, so every test waits for its own requests to finish.
33
+ */
34
+ export const settleRequests = async (client: Client) => {
35
+ cleanup();
36
+ openGates.forEach((open) => open());
37
+ openGates.clear();
38
+ await waitFor(() => expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(0));
39
+ };
40
+
41
+ /**
42
+ * The shared request mock matches by path only - lists need the response to depend on the query params
43
+ */
44
+ export const createListServer = () => {
45
+ const mocking = createHttpMockingServer();
46
+ const calls: ListCall[] = [];
47
+
48
+ const respond = async (request: Request, handler: (call: ListCall) => ListResult | Promise<ListResult>) => {
49
+ const url = new URL(request.url);
50
+ const body = request.method === "GET" ? null : await request.clone().json();
51
+ const call = { path: url.pathname, query: Object.fromEntries(url.searchParams.entries()), body };
52
+ calls.push(call);
53
+
54
+ await wait(5);
55
+ const result: any = await handler(call);
56
+
57
+ if (result?.__failure) {
58
+ return HttpResponse.json({ message: "Failed" }, { status: result.__failure });
59
+ }
60
+ return HttpResponse.json(result as any);
61
+ };
62
+
63
+ const mockList = (path: string, handler: (call: ListCall) => ListResult | Promise<ListResult>) => {
64
+ mocking.server.use(http.get(`${baseUrl}${path}`, ({ request }) => respond(request, handler)));
65
+ };
66
+
67
+ const mockListPost = (path: string, handler: (call: ListCall) => ListResult | Promise<ListResult>) => {
68
+ mocking.server.use(http.post(`${baseUrl}${path}`, ({ request }) => respond(request, handler)));
69
+ };
70
+
71
+ return {
72
+ ...mocking,
73
+ calls,
74
+ mockList,
75
+ mockListPost,
76
+ resetCalls: () => {
77
+ calls.length = 0;
78
+ },
79
+ };
80
+ };
81
+
82
+ /** Numbers of the items on a page, e.g. page 2 of size 2 holds [3, 4] */
83
+ export const pageItems = (page: number, size = 2) => {
84
+ return Array.from({ length: size }, (_, index) => ({ id: (page - 1) * size + index + 1 }));
85
+ };
86
+
87
+ export const sleep = (time: number) =>
88
+ new Promise((resolve) => {
89
+ setTimeout(resolve, time);
90
+ });
@@ -1 +1 @@
1
- {"version":3,"file":"use-request-events.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-request-events/use-request-events.hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAQhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAOV,0BAA0B,EAC1B,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAIjB;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,eAAe,EAAE,8EAOzD,yBAAyB,CAAC,CAAC,CAAC,KAAG,0BAA0B,CAAC,CAAC,CAiT7D,CAAC"}
1
+ {"version":3,"file":"use-request-events.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-request-events/use-request-events.hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAQhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAOV,0BAA0B,EAC1B,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAIjB;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,eAAe,EAAE,8EAOzD,yBAAyB,CAAC,CAAC,CAAC,KAAG,0BAA0B,CAAC,CAAC,CA2T7D,CAAC"}
@@ -0,0 +1,4 @@
1
+ export * from './use-infinite-fetch.constants';
2
+ export * from './use-infinite-fetch.hooks';
3
+ export * from './use-infinite-fetch.types';
4
+ //# sourceMappingURL=index.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-infinite-fetch/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}
@@ -0,0 +1,22 @@
1
+ import { Time } from '@hyper-fetch/core';
2
+ export declare const useInfiniteFetchDefaultOptions: {
3
+ suspense: false;
4
+ throwOnError: false;
5
+ dependencies: never[];
6
+ disabled: false;
7
+ dependencyTracking: true;
8
+ revalidate: false;
9
+ keepPreviousData: "auto";
10
+ refresh: false;
11
+ refreshTime: Time;
12
+ refetchBlurred: true;
13
+ refetchOnBlur: false;
14
+ refetchOnFocus: false;
15
+ refetchOnReconnect: false;
16
+ structuralSharing: true;
17
+ bounce: false;
18
+ bounceType: "debounce";
19
+ bounceTime: number;
20
+ bounceTimeout: number;
21
+ };
22
+ //# sourceMappingURL=use-infinite-fetch.constants.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"use-infinite-fetch.constants.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAIzC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;CAoBK,CAAC"}
@@ -0,0 +1,21 @@
1
+ import { Pagination, PaginationItem, RequestInstance } from '@hyper-fetch/core';
2
+ import { UseInfiniteFetchOptionsType, UseInfiniteFetchReturnType } from './use-infinite-fetch.types';
3
+ /**
4
+ * Loads a list page by page. Say which fields page through the request, and the hook takes care of the rest:
5
+ * every page is a normal request under its own cache key, and the hook glues them together.
6
+ *
7
+ * A changed filter, sort or URL param starts a new list on its own. When to load more is up to you - call
8
+ * `fetchNextPage` from a button, an intersection observer, `onEndReached` or a virtualizer.
9
+ *
10
+ * @param request Request instance
11
+ * @param options Hook options, `pagination` is required
12
+ * @returns
13
+ * @example
14
+ * ```tsx
15
+ * const { items, hasNextPage, fetchNextPage } = useInfiniteFetch(getFeed.setQueryParams({ topic }), {
16
+ * pagination: { cursor: "cursor", next: "nextCursor", items: "data" },
17
+ * });
18
+ * ```
19
+ */
20
+ export declare const useInfiniteFetch: <R extends RequestInstance, const P extends Pagination<R>, TSelected = PaginationItem<R, P>[]>(request: R, options: UseInfiniteFetchOptionsType<R, P, TSelected>) => UseInfiniteFetchReturnType<R, P, TSelected>;
21
+ //# sourceMappingURL=use-infinite-fetch.hooks.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"use-infinite-fetch.hooks.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,UAAU,EAEV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAW3B,OAAO,KAAK,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAkC1G;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,eAAe,EACzB,KAAK,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAC7B,SAAS,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAElC,SAAS,CAAC,EACV,SAAS,2BAA2B,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,KACpD,0BAA0B,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAuT5C,CAAC"}
@@ -0,0 +1,19 @@
1
+ import { RequestInstance } from '@hyper-fetch/core';
2
+ type LoadPageOptions = {
3
+ request: RequestInstance;
4
+ /** Skips requests started before this fetch was asked for */
5
+ force: boolean;
6
+ /** Filled with the functions stopping this fetch */
7
+ cancellers: Set<VoidFunction>;
8
+ isCancelled: () => boolean;
9
+ };
10
+ /**
11
+ * Cancelled pages are not failures: the list simply did not need them anymore
12
+ */
13
+ export declare const isCancelledResponse: (response: any) => boolean;
14
+ /**
15
+ * Loads a page, reusing the request already running for it
16
+ */
17
+ export declare const loadPage: (options: LoadPageOptions) => Promise<import('@hyper-fetch/core').RequestResponseType<RequestInstance> | null>;
18
+ export {};
19
+ //# sourceMappingURL=use-infinite-fetch.requests.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"use-infinite-fetch.requests.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,eAAe,CAAC;IACzB,6DAA6D;IAC7D,KAAK,EAAE,OAAO,CAAC;IACf,oDAAoD;IACpD,UAAU,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,GAAG,YAMhD,CAAC;AAoDF;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAU,SAAS,eAAe,qFAqBtD,CAAC"}