@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.
- package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
- package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
- package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
- package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
- package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
- package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
- package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
- package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
- package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +2 -1
- package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
- package/__tests__/features/use-submit/use-submit.unmount.spec.ts +311 -0
- package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
- package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
- package/__tests__/utils/use-queue.utils.ts +8 -4
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
- package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +917 -3
- package/dist/index.mjs.map +1 -1
- package/dist/provider/provider.types.d.ts +2 -0
- package/dist/provider/provider.types.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +17 -5
- package/src/hooks/use-infinite-fetch/index.ts +3 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
- package/src/index.ts +1 -0
- package/src/provider/provider.types.ts +3 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
|
@@ -0,0 +1,311 @@
|
|
|
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
|
+
// Two polling waitFors run before the abort, so the request has to stay in flight far longer than their 50ms
|
|
203
|
+
mockRequest(setup.mutation, { data: { ok: true }, delay: 1000 });
|
|
204
|
+
|
|
205
|
+
const { requestId, callbacks, pending } = await submitAndUnmount(setup);
|
|
206
|
+
await waitFor(() => {
|
|
207
|
+
expect(setup.dispatcher.getAllRunningRequests()).toHaveLength(1);
|
|
208
|
+
});
|
|
209
|
+
setup.mutation.abort();
|
|
210
|
+
await pending;
|
|
211
|
+
|
|
212
|
+
expectNoCallbacks(callbacks);
|
|
213
|
+
expect(setup.rollback).toHaveBeenCalledTimes(1);
|
|
214
|
+
expect(setup.rollback.mock.calls[0][0].reason).toBe("abort");
|
|
215
|
+
await expectNoRequestListeners(setup, requestId);
|
|
216
|
+
});
|
|
217
|
+
|
|
218
|
+
it("should roll back once when removed from the queue", async () => {
|
|
219
|
+
const setup = createSetup();
|
|
220
|
+
setup.dispatcher.stop(setup.queryKey);
|
|
221
|
+
|
|
222
|
+
const { requestId, callbacks, pending } = await submitAndUnmount(setup);
|
|
223
|
+
setup.dispatcher.delete(setup.queryKey, requestId, setup.abortKey);
|
|
224
|
+
await pending;
|
|
225
|
+
|
|
226
|
+
expectNoCallbacks(callbacks);
|
|
227
|
+
expect(setup.rollback).toHaveBeenCalledTimes(1);
|
|
228
|
+
expect(setup.rollback.mock.calls[0][0].reason).toBe("removed");
|
|
229
|
+
await expectNoRequestListeners(setup, requestId);
|
|
230
|
+
});
|
|
231
|
+
|
|
232
|
+
it("should fire no callback when the optimistic callback resolves after unmount", async () => {
|
|
233
|
+
const setup = createSetup();
|
|
234
|
+
let resolveOptimistic: (value: OptimisticCallbackResult<undefined>) => void = () => undefined;
|
|
235
|
+
const request = setup.mutation.setOptimistic(
|
|
236
|
+
() =>
|
|
237
|
+
new Promise<OptimisticCallbackResult<undefined>>((resolve) => {
|
|
238
|
+
resolveOptimistic = resolve;
|
|
239
|
+
}),
|
|
240
|
+
);
|
|
241
|
+
mockRequest(request, { status: 400 });
|
|
242
|
+
const { result, unmount, callbacks } = renderSubmit(request);
|
|
243
|
+
let pending: ReturnType<typeof result.current.submit> | undefined;
|
|
244
|
+
|
|
245
|
+
act(() => {
|
|
246
|
+
pending = result.current.submit();
|
|
247
|
+
});
|
|
248
|
+
unmount();
|
|
249
|
+
resolveOptimistic({ rollback: setup.rollback });
|
|
250
|
+
await pending;
|
|
251
|
+
|
|
252
|
+
expectNoCallbacks(callbacks);
|
|
253
|
+
expect(setup.rollback).toHaveBeenCalledTimes(1);
|
|
254
|
+
});
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
describe("when submitted after unmount", () => {
|
|
258
|
+
it("should settle the request and leave no listeners behind", async () => {
|
|
259
|
+
const setup = createSetup();
|
|
260
|
+
mockRequest(setup.mutation, { status: 400 });
|
|
261
|
+
const requestListeners = countListeners(setup.client.requestManager.emitter);
|
|
262
|
+
const cacheListeners = countListeners(setup.client.cache.emitter);
|
|
263
|
+
const { result, unmount, callbacks } = renderSubmit(setup.mutation);
|
|
264
|
+
|
|
265
|
+
unmount();
|
|
266
|
+
const response = await result.current.submit();
|
|
267
|
+
|
|
268
|
+
expect(response.status).toBe(400);
|
|
269
|
+
expectNoCallbacks(callbacks);
|
|
270
|
+
expect(setup.rollback).toHaveBeenCalledTimes(1);
|
|
271
|
+
await waitFor(() => {
|
|
272
|
+
expect(countListeners(setup.client.requestManager.emitter)).toBe(requestListeners);
|
|
273
|
+
});
|
|
274
|
+
expect(countListeners(setup.client.cache.emitter)).toBe(cacheListeners);
|
|
275
|
+
});
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
describe("when staying mounted", () => {
|
|
279
|
+
it("should keep delivering callbacks", async () => {
|
|
280
|
+
const setup = createSetup();
|
|
281
|
+
mockRequest(setup.mutation, { data: { ok: true } });
|
|
282
|
+
const { result, callbacks } = renderSubmit(setup.mutation);
|
|
283
|
+
|
|
284
|
+
await act(async () => {
|
|
285
|
+
await result.current.submit();
|
|
286
|
+
});
|
|
287
|
+
|
|
288
|
+
await waitFor(() => {
|
|
289
|
+
expect(callbacks.onSubmitSuccess).toHaveBeenCalledTimes(1);
|
|
290
|
+
});
|
|
291
|
+
expect(callbacks.onSubmitFinished).toHaveBeenCalledTimes(1);
|
|
292
|
+
expect(callbacks.onSubmitRequestStart).toHaveBeenCalledTimes(1);
|
|
293
|
+
expect(callbacks.onSubmitError).not.toHaveBeenCalled();
|
|
294
|
+
});
|
|
295
|
+
|
|
296
|
+
it("should keep receiving cache updates", async () => {
|
|
297
|
+
const setup = createSetup();
|
|
298
|
+
mockRequest(setup.mutation, { data: { ok: true } });
|
|
299
|
+
const { result } = renderHook(() => useSubmit(setup.mutation, { dependencyTracking: false }), { wrapper });
|
|
300
|
+
|
|
301
|
+
await act(async () => {
|
|
302
|
+
await result.current.submit();
|
|
303
|
+
});
|
|
304
|
+
|
|
305
|
+
await waitFor(() => {
|
|
306
|
+
expect(result.current.data).toStrictEqual({ ok: true });
|
|
307
|
+
});
|
|
308
|
+
});
|
|
309
|
+
});
|
|
310
|
+
});
|
|
311
|
+
});
|
|
@@ -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
|
+
});
|
|
@@ -33,8 +33,10 @@ export const emitDownloadProgress = <T extends RequestInstance>(
|
|
|
33
33
|
},
|
|
34
34
|
) => {
|
|
35
35
|
const values = options || { total: 50, loaded: 25 };
|
|
36
|
-
|
|
37
|
-
const
|
|
36
|
+
// One clock read so the elapsed time is exactly 20s, even when the clock ticks in between
|
|
37
|
+
const now = Date.now();
|
|
38
|
+
const startTimestamp = new Date(now - 20_000);
|
|
39
|
+
const progressTimestamp = new Date(now);
|
|
38
40
|
|
|
39
41
|
const progress = getProgressData(startTimestamp, progressTimestamp, values);
|
|
40
42
|
request.client.requestManager.events.emitDownloadProgress({
|
|
@@ -55,8 +57,10 @@ export const emitUploadProgress = <T extends RequestInstance>(
|
|
|
55
57
|
},
|
|
56
58
|
) => {
|
|
57
59
|
const values = options || { total: 50, loaded: 25 };
|
|
58
|
-
|
|
59
|
-
const
|
|
60
|
+
// One clock read so the elapsed time is exactly 20s, even when the clock ticks in between
|
|
61
|
+
const now = Date.now();
|
|
62
|
+
const startTimestamp = new Date(now - 20_000);
|
|
63
|
+
const progressTimestamp = new Date(now);
|
|
60
64
|
|
|
61
65
|
const progress = getProgressData(startTimestamp, progressTimestamp, values);
|
|
62
66
|
request.client.requestManager.events.emitUploadProgress({
|
|
@@ -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,
|
|
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,CA6T7D,CAAC"}
|
|
@@ -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"}
|