@hyper-fetch/react 9.2.0 → 9.4.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 (79) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.base.spec.ts +2 -2
  2. package/__tests__/features/strict-mode/strict-mode.requests.spec.ts +45 -0
  3. package/__tests__/features/strict-mode/strict-mode.sockets.spec.ts +21 -0
  4. package/__tests__/features/use-cache/use-cache.select.spec.tsx +117 -0
  5. package/__tests__/features/use-cache/use-cache.typescript.spec.ts +10 -0
  6. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +17 -14
  7. package/__tests__/features/use-fetch/use-fetch.select.spec.tsx +420 -0
  8. package/__tests__/features/use-fetch/use-fetch.throw-on-error.spec.tsx +213 -0
  9. package/__tests__/features/use-fetch/use-fetch.typescript.spec.ts +41 -0
  10. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +117 -0
  11. package/__tests__/features/use-listener/use-listener.select.spec.tsx +183 -0
  12. package/__tests__/features/use-listener/use-listener.typescript.spec.ts +23 -0
  13. package/__tests__/features/use-submit/use-submit.select.spec.tsx +55 -0
  14. package/__tests__/features/use-submit/use-submit.typescript.spec.ts +14 -0
  15. package/__tests__/utils/use-fetch.utils.ts +4 -1
  16. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  17. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  18. package/dist/helpers/use-socket-state/use-socket-state.hooks.d.ts +2 -0
  19. package/dist/helpers/use-socket-state/use-socket-state.hooks.d.ts.map +1 -1
  20. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts +2 -2
  21. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  22. package/dist/helpers/use-tracked-state/use-tracked-state.types.d.ts +23 -10
  23. package/dist/helpers/use-tracked-state/use-tracked-state.types.d.ts.map +1 -1
  24. package/dist/hooks/use-cache/use-cache.constants.d.ts +1 -0
  25. package/dist/hooks/use-cache/use-cache.constants.d.ts.map +1 -1
  26. package/dist/hooks/use-cache/use-cache.hooks.d.ts +2 -2
  27. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  28. package/dist/hooks/use-cache/use-cache.types.d.ts +12 -3
  29. package/dist/hooks/use-cache/use-cache.types.d.ts.map +1 -1
  30. package/dist/hooks/use-fetch/use-fetch.constants.d.ts +1 -1
  31. package/dist/hooks/use-fetch/use-fetch.constants.d.ts.map +1 -1
  32. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts +2 -2
  33. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  34. package/dist/hooks/use-fetch/use-fetch.types.d.ts +18 -4
  35. package/dist/hooks/use-fetch/use-fetch.types.d.ts.map +1 -1
  36. package/dist/hooks/use-is-fetching/index.d.ts +3 -0
  37. package/dist/hooks/use-is-fetching/index.d.ts.map +1 -0
  38. package/dist/hooks/use-is-fetching/use-is-fetching.hooks.d.ts +17 -0
  39. package/dist/hooks/use-is-fetching/use-is-fetching.hooks.d.ts.map +1 -0
  40. package/dist/hooks/use-is-fetching/use-is-fetching.types.d.ts +12 -0
  41. package/dist/hooks/use-is-fetching/use-is-fetching.types.d.ts.map +1 -0
  42. package/dist/hooks/use-listener/use-listener.hooks.d.ts +3 -3
  43. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  44. package/dist/hooks/use-listener/use-listener.types.d.ts +12 -1
  45. package/dist/hooks/use-listener/use-listener.types.d.ts.map +1 -1
  46. package/dist/hooks/use-submit/use-submit.constants.d.ts +1 -1
  47. package/dist/hooks/use-submit/use-submit.constants.d.ts.map +1 -1
  48. package/dist/hooks/use-submit/use-submit.hooks.d.ts +2 -2
  49. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  50. package/dist/hooks/use-submit/use-submit.types.d.ts +13 -4
  51. package/dist/hooks/use-submit/use-submit.types.d.ts.map +1 -1
  52. package/dist/index.d.ts +1 -0
  53. package/dist/index.d.ts.map +1 -1
  54. package/dist/index.mjs +181 -35
  55. package/dist/index.mjs.map +1 -1
  56. package/dist/provider/provider.types.d.ts +6 -4
  57. package/dist/provider/provider.types.d.ts.map +1 -1
  58. package/package.json +1 -1
  59. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  60. package/src/helpers/use-socket-state/use-socket-state.hooks.ts +3 -1
  61. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +112 -26
  62. package/src/helpers/use-tracked-state/use-tracked-state.types.ts +27 -9
  63. package/src/hooks/use-cache/use-cache.constants.ts +1 -0
  64. package/src/hooks/use-cache/use-cache.hooks.ts +9 -7
  65. package/src/hooks/use-cache/use-cache.types.ts +16 -4
  66. package/src/hooks/use-emitter/use-emitter.hooks.ts +1 -1
  67. package/src/hooks/use-fetch/use-fetch.constants.ts +3 -1
  68. package/src/hooks/use-fetch/use-fetch.hooks.ts +38 -6
  69. package/src/hooks/use-fetch/use-fetch.types.ts +33 -5
  70. package/src/hooks/use-is-fetching/index.ts +2 -0
  71. package/src/hooks/use-is-fetching/use-is-fetching.hooks.ts +51 -0
  72. package/src/hooks/use-is-fetching/use-is-fetching.types.ts +12 -0
  73. package/src/hooks/use-listener/use-listener.hooks.ts +61 -6
  74. package/src/hooks/use-listener/use-listener.types.ts +12 -1
  75. package/src/hooks/use-submit/use-submit.constants.ts +2 -1
  76. package/src/hooks/use-submit/use-submit.hooks.ts +22 -7
  77. package/src/hooks/use-submit/use-submit.types.ts +23 -7
  78. package/src/index.ts +1 -0
  79. package/src/provider/provider.types.ts +8 -4
@@ -0,0 +1,420 @@
1
+ import type { ExtractResponseType, RequestInstance } from "@hyper-fetch/core";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+ import { act, render, screen, waitFor } from "@testing-library/react";
4
+ import { useFetch } from "hooks/use-fetch";
5
+ import type { ReactNode } from "react";
6
+ import { Component, Suspense, useEffect } from "react";
7
+
8
+ import { client, createRequest } from "../../utils";
9
+
10
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
11
+
12
+ type Symbols = Record<string, { price: number; name: string }>;
13
+
14
+ class ErrorBoundary extends Component<{ children: ReactNode }, { error: Error | null }> {
15
+ constructor(props: { children: ReactNode }) {
16
+ super(props);
17
+ this.state = { error: null };
18
+ }
19
+
20
+ static getDerivedStateFromError(error: Error) {
21
+ return { error };
22
+ }
23
+
24
+ render() {
25
+ const { error } = this.state;
26
+ const { children } = this.props;
27
+ if (error) {
28
+ return <div data-testid="error-boundary">{error.message}</div>;
29
+ }
30
+ return children;
31
+ }
32
+ }
33
+
34
+ describe("useFetch [ Select ]", () => {
35
+ const symbols: Symbols = {
36
+ btc: { price: 1, name: "Bitcoin" },
37
+ eth: { price: 2, name: "Ethereum" },
38
+ };
39
+
40
+ let request = createRequest<Symbols>();
41
+
42
+ const setCacheData = (req: RequestInstance, data: ExtractResponseType<typeof request>) => {
43
+ act(() => {
44
+ client.cache.set(req, {
45
+ data,
46
+ error: null,
47
+ status: 200,
48
+ success: true,
49
+ extra: {},
50
+ retries: 0,
51
+ isCanceled: false,
52
+ isOffline: false,
53
+ willRetry: false,
54
+ addedTimestamp: Date.now(),
55
+ triggerTimestamp: Date.now(),
56
+ requestTimestamp: Date.now(),
57
+ responseTimestamp: Date.now(),
58
+ });
59
+ });
60
+ };
61
+
62
+ const waitForData = async (testId = "result") => {
63
+ await waitFor(() => {
64
+ expect(screen.getByTestId(testId).textContent).not.toBe("null");
65
+ });
66
+ };
67
+
68
+ beforeAll(() => {
69
+ startServer();
70
+ });
71
+
72
+ afterEach(() => {
73
+ resetMocks();
74
+ });
75
+
76
+ afterAll(() => {
77
+ stopServer();
78
+ });
79
+
80
+ beforeEach(() => {
81
+ vi.resetModules();
82
+ client.clear();
83
+ request = createRequest<Symbols>();
84
+ });
85
+
86
+ describe("when selecting part of the response", () => {
87
+ it("should return the selected data", async () => {
88
+ mockRequest(request, { data: symbols });
89
+
90
+ function Page() {
91
+ const { data } = useFetch(request, { select: (value) => value.btc });
92
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
93
+ }
94
+
95
+ render(<Page />);
96
+
97
+ await waitFor(() => {
98
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify(symbols.btc));
99
+ });
100
+ });
101
+
102
+ it("should share one request between hooks selecting different parts", async () => {
103
+ mockRequest(request, { data: symbols });
104
+ const responseSpy = vi.fn();
105
+ const unmount = client.requestManager.events.onResponse(responseSpy);
106
+
107
+ function Price({ id }: { id: string }) {
108
+ const { data } = useFetch(request, { select: (value) => value[id].price });
109
+ return <div data-testid={id}>{JSON.stringify(data)}</div>;
110
+ }
111
+
112
+ render(
113
+ <>
114
+ <Price id="btc" />
115
+ <Price id="eth" />
116
+ </>,
117
+ );
118
+
119
+ await waitFor(() => {
120
+ expect(screen.getByTestId("btc").textContent).toBe("1");
121
+ expect(screen.getByTestId("eth").textContent).toBe("2");
122
+ });
123
+ expect(responseSpy).toHaveBeenCalledTimes(1);
124
+ unmount();
125
+ });
126
+
127
+ it("should not rerender when the unselected part of the data changes", async () => {
128
+ mockRequest(request, { data: symbols });
129
+ let renders = 0;
130
+
131
+ function Page() {
132
+ const { data } = useFetch(request, { select: (value) => value.btc });
133
+ renders += 1;
134
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
135
+ }
136
+
137
+ render(<Page />);
138
+ await waitForData();
139
+ const rendersAfterLoad = renders;
140
+
141
+ setCacheData(request, { ...symbols, eth: { price: 999, name: "Ethereum" } });
142
+ setCacheData(request, { ...symbols, eth: { price: 1000, name: "Ethereum" } });
143
+
144
+ expect(renders).toBe(rendersAfterLoad);
145
+
146
+ setCacheData(request, { ...symbols, btc: { price: 5, name: "Bitcoin" } });
147
+
148
+ expect(renders).toBe(rendersAfterLoad + 1);
149
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify({ price: 5, name: "Bitcoin" }));
150
+ });
151
+
152
+ it("should keep the reference of a recreated selected object when it is deeply equal", async () => {
153
+ mockRequest(request, { data: symbols });
154
+ const references = new Set<unknown>();
155
+ const effectSpy = vi.fn();
156
+
157
+ function Page() {
158
+ // Inline selector creating a new object on every call
159
+ const { data, loading } = useFetch(request, { select: (value) => ({ price: value.btc.price }) });
160
+ if (data) {
161
+ references.add(data);
162
+ }
163
+ useEffect(() => {
164
+ effectSpy();
165
+ }, [data]);
166
+ return <div data-testid="result">{loading ? "loading" : JSON.stringify(data)}</div>;
167
+ }
168
+
169
+ render(<Page />);
170
+ await waitFor(() => {
171
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify({ price: 1 }));
172
+ });
173
+ const effectsAfterLoad = effectSpy.mock.calls.length;
174
+
175
+ setCacheData(request, { ...symbols, eth: { price: 3, name: "Ethereum" } });
176
+ setCacheData(request, { btc: { price: 1, name: "Renamed" }, eth: { price: 3, name: "Ethereum" } });
177
+
178
+ expect(references.size).toBe(1);
179
+ expect(effectSpy).toHaveBeenCalledTimes(effectsAfterLoad);
180
+ });
181
+
182
+ it("should re-run the selector when it changes between renders", async () => {
183
+ mockRequest(request, { data: symbols });
184
+
185
+ function Page({ id }: { id: string }) {
186
+ const { data } = useFetch(request, { select: (value) => value[id].name });
187
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
188
+ }
189
+
190
+ const view = render(<Page id="btc" />);
191
+ await waitFor(() => {
192
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify("Bitcoin"));
193
+ });
194
+
195
+ view.rerender(<Page id="eth" />);
196
+
197
+ // Same render - without waiting for any new data
198
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify("Ethereum"));
199
+ });
200
+
201
+ it("should apply the selector to the cached data on mount", async () => {
202
+ setCacheData(request, symbols);
203
+
204
+ function Page() {
205
+ const { data } = useFetch(request, { select: (value) => value.eth.price, revalidate: false });
206
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
207
+ }
208
+
209
+ render(<Page />);
210
+
211
+ expect(screen.getByTestId("result").textContent).toBe("2");
212
+ });
213
+
214
+ it("should apply the selector to the initial response", async () => {
215
+ mockRequest(request, { data: symbols, delay: 50 });
216
+
217
+ function Page() {
218
+ const { data } = useFetch(request, {
219
+ select: (value) => value.btc.name,
220
+ initialResponse: { data: { btc: { price: 0, name: "Initial" } } },
221
+ });
222
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
223
+ }
224
+
225
+ render(<Page />);
226
+
227
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify("Initial"));
228
+ await waitFor(() => {
229
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify("Bitcoin"));
230
+ });
231
+ });
232
+
233
+ it("should keep the data set locally with setData while selector is recreated on every render", async () => {
234
+ mockRequest(request, { data: symbols });
235
+ let setData: ((value: number) => void) | null = null;
236
+
237
+ function Page() {
238
+ const view = useFetch(request, { select: (value) => value.btc.price });
239
+ setData = view.setData;
240
+ return <div data-testid="result">{JSON.stringify(view.data)}</div>;
241
+ }
242
+
243
+ render(<Page />);
244
+ await waitFor(() => {
245
+ expect(screen.getByTestId("result").textContent).toBe("1");
246
+ });
247
+
248
+ act(() => {
249
+ setData?.(42);
250
+ });
251
+
252
+ expect(screen.getByTestId("result").textContent).toBe("42");
253
+
254
+ // Next response replaces the local data
255
+ setCacheData(request, { ...symbols, btc: { price: 7, name: "Bitcoin" } });
256
+ expect(screen.getByTestId("result").textContent).toBe("7");
257
+ });
258
+
259
+ it("should not call the selector for empty data", async () => {
260
+ mockRequest(request, { status: 400, delay: 10 });
261
+ const selectSpy = vi.fn((value: Symbols) => value.btc);
262
+
263
+ function Page() {
264
+ const { data, error } = useFetch(request, { select: selectSpy });
265
+ return <div data-testid="result">{error ? "error" : JSON.stringify(data)}</div>;
266
+ }
267
+
268
+ render(<Page />);
269
+
270
+ await waitFor(() => {
271
+ expect(screen.getByTestId("result").textContent).toBe("error");
272
+ });
273
+ expect(selectSpy).not.toHaveBeenCalled();
274
+ });
275
+
276
+ it("should pass the selector error to the error boundary", async () => {
277
+ mockRequest(request, { data: symbols });
278
+ vi.spyOn(console, "error").mockImplementation(() => null);
279
+
280
+ function Page() {
281
+ const { data } = useFetch(request, {
282
+ select: (value) => {
283
+ if (value.btc.price > 1) {
284
+ throw new Error("Selector failed");
285
+ }
286
+ return value.btc;
287
+ },
288
+ });
289
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
290
+ }
291
+
292
+ render(
293
+ <ErrorBoundary>
294
+ <Page />
295
+ </ErrorBoundary>,
296
+ );
297
+ await waitForData();
298
+
299
+ setCacheData(request, { ...symbols, btc: { price: 2, name: "Bitcoin" } });
300
+
301
+ await waitFor(() => {
302
+ expect(screen.getByTestId("error-boundary").textContent).toBe("Selector failed");
303
+ });
304
+ });
305
+
306
+ it("should apply the selector in suspense mode", async () => {
307
+ mockRequest(request, { data: symbols });
308
+
309
+ function Page() {
310
+ const { data } = useFetch(request, { suspense: true, select: (value) => value.eth.name });
311
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
312
+ }
313
+
314
+ render(
315
+ <Suspense fallback={<div data-testid="fallback" />}>
316
+ <Page />
317
+ </Suspense>,
318
+ );
319
+
320
+ await waitFor(() => {
321
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify("Ethereum"));
322
+ });
323
+ });
324
+ });
325
+
326
+ describe("when using structural sharing", () => {
327
+ it("should keep the data reference when the same data is received again", async () => {
328
+ mockRequest(request, { data: symbols });
329
+ const effectSpy = vi.fn();
330
+ let refetch: (() => void) | null = null;
331
+
332
+ function Page() {
333
+ const view = useFetch(request);
334
+ refetch = view.refetch;
335
+ useEffect(() => {
336
+ effectSpy(view.data);
337
+ }, [view.data]);
338
+ return <div data-testid="result">{view.loading ? "loading" : JSON.stringify(view.data)}</div>;
339
+ }
340
+
341
+ render(<Page />);
342
+ await waitFor(() => {
343
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify(symbols));
344
+ });
345
+ const firstData = effectSpy.mock.lastCall?.[0];
346
+
347
+ act(() => {
348
+ refetch?.();
349
+ });
350
+ await waitFor(() => {
351
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify(symbols));
352
+ });
353
+
354
+ expect(effectSpy.mock.lastCall?.[0]).toBe(firstData);
355
+ // null -> data, never a second time for the equal response
356
+ expect(effectSpy.mock.calls.filter(([value]) => value !== null)).toHaveLength(1);
357
+ });
358
+
359
+ it("should reuse unchanged parts of the data", async () => {
360
+ setCacheData(request, symbols);
361
+ let current: Symbols | null = null;
362
+
363
+ function Page() {
364
+ const { data } = useFetch(request, { revalidate: false });
365
+ current = data;
366
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
367
+ }
368
+
369
+ render(<Page />);
370
+ const first = current as unknown as Symbols;
371
+
372
+ setCacheData(request, { btc: { price: 1, name: "Bitcoin" }, eth: { price: 5, name: "Ethereum" } });
373
+ const second = current as unknown as Symbols;
374
+
375
+ expect(second).not.toBe(first);
376
+ expect(second.btc).toBe(first.btc);
377
+ expect(second.eth).toStrictEqual({ price: 5, name: "Ethereum" });
378
+ });
379
+
380
+ it("should allow to disable structural sharing of the selected data", async () => {
381
+ setCacheData(request, symbols);
382
+ let current: unknown = null;
383
+
384
+ function Page() {
385
+ const { data } = useFetch(request, {
386
+ revalidate: false,
387
+ structuralSharing: false,
388
+ deepCompare: false,
389
+ select: (value) => ({ price: value.btc.price }),
390
+ });
391
+ current = data;
392
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
393
+ }
394
+
395
+ render(<Page />);
396
+ const first = current;
397
+ setCacheData(request, { ...symbols, eth: { price: 3, name: "Ethereum" } });
398
+
399
+ expect(current).not.toBe(first);
400
+ expect(current).toStrictEqual(first);
401
+ });
402
+
403
+ it("should give new references when sharing is disabled everywhere", async () => {
404
+ const unsharedRequest = request.setStructuralSharing(false);
405
+ setCacheData(unsharedRequest, symbols);
406
+ const references = new Set<unknown>();
407
+
408
+ function Page() {
409
+ const { data } = useFetch(unsharedRequest, { revalidate: false, deepCompare: false });
410
+ references.add(data);
411
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
412
+ }
413
+
414
+ render(<Page />);
415
+ setCacheData(unsharedRequest, { ...symbols });
416
+
417
+ expect(references.size).toBe(2);
418
+ });
419
+ });
420
+ });
@@ -0,0 +1,213 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+ import { act, render, screen, waitFor } from "@testing-library/react";
3
+ import { useFetch } from "hooks/use-fetch";
4
+ import type { ReactNode } from "react";
5
+ import { Component, Suspense } from "react";
6
+
7
+ import { client, createRequest } from "../../utils";
8
+
9
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
10
+
11
+ class ErrorBoundary extends Component<{ children: ReactNode }, { error: unknown }> {
12
+ constructor(props: { children: ReactNode }) {
13
+ super(props);
14
+ this.state = { error: null };
15
+ }
16
+
17
+ static getDerivedStateFromError(error: unknown) {
18
+ return { error };
19
+ }
20
+
21
+ handleReset = () => {
22
+ // eslint-disable-next-line react/no-set-state
23
+ this.setState({ error: null });
24
+ };
25
+
26
+ render() {
27
+ const { error } = this.state;
28
+ const { children } = this.props;
29
+ if (error) {
30
+ return (
31
+ <button type="button" data-testid="error-boundary" onClick={this.handleReset}>
32
+ {JSON.stringify(error)}
33
+ </button>
34
+ );
35
+ }
36
+ return children;
37
+ }
38
+ }
39
+
40
+ describe("useFetch [ Throw On Error ]", () => {
41
+ let request = createRequest();
42
+
43
+ beforeAll(() => {
44
+ startServer();
45
+ });
46
+
47
+ afterEach(() => {
48
+ resetMocks();
49
+ });
50
+
51
+ afterAll(() => {
52
+ stopServer();
53
+ });
54
+
55
+ beforeEach(() => {
56
+ vi.resetModules();
57
+ vi.restoreAllMocks();
58
+ // React logs the errors caught by boundaries
59
+ vi.spyOn(console, "error").mockImplementation(() => null);
60
+ client.clear();
61
+ request = createRequest();
62
+ });
63
+
64
+ function Page({ throwOnError }: { throwOnError: boolean | ((error: any) => boolean) }) {
65
+ // Component does not read the error - the hook still has to throw it
66
+ const { data, loading } = useFetch(request, { throwOnError });
67
+ return <div data-testid="result">{loading ? "loading" : JSON.stringify(data)}</div>;
68
+ }
69
+
70
+ it("should throw the error to the error boundary", async () => {
71
+ const error = mockRequest(request, { status: 400 });
72
+
73
+ render(
74
+ <ErrorBoundary>
75
+ <Page throwOnError />
76
+ </ErrorBoundary>,
77
+ );
78
+
79
+ await waitFor(() => {
80
+ expect(screen.getByTestId("error-boundary").textContent).toBe(JSON.stringify(error));
81
+ });
82
+ });
83
+
84
+ it("should not throw when the request succeeds", async () => {
85
+ const data = mockRequest(request, { data: { value: 1 } });
86
+
87
+ render(
88
+ <ErrorBoundary>
89
+ <Page throwOnError />
90
+ </ErrorBoundary>,
91
+ );
92
+
93
+ await waitFor(() => {
94
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify(data));
95
+ });
96
+ expect(screen.queryByTestId("error-boundary")).toBeNull();
97
+ });
98
+
99
+ it("should keep the error in the state when disabled", async () => {
100
+ mockRequest(request, { status: 400 });
101
+
102
+ function ErrorPage() {
103
+ const { error, loading } = useFetch(request);
104
+ const status = error ? "error" : "none";
105
+ return <div data-testid="result">{loading ? "loading" : status}</div>;
106
+ }
107
+
108
+ render(
109
+ <ErrorBoundary>
110
+ <ErrorPage />
111
+ </ErrorBoundary>,
112
+ );
113
+
114
+ await waitFor(() => {
115
+ expect(screen.getByTestId("result").textContent).toBe("error");
116
+ });
117
+ expect(screen.queryByTestId("error-boundary")).toBeNull();
118
+ });
119
+
120
+ it("should decide with the predicate", async () => {
121
+ mockRequest(request, { status: 400 });
122
+ const predicate = vi.fn(() => false);
123
+
124
+ render(
125
+ <ErrorBoundary>
126
+ <Page throwOnError={predicate} />
127
+ </ErrorBoundary>,
128
+ );
129
+
130
+ await waitFor(() => {
131
+ expect(predicate).toHaveBeenCalled();
132
+ });
133
+ expect(screen.queryByTestId("error-boundary")).toBeNull();
134
+ expect(predicate.mock.calls[0]).toHaveLength(1);
135
+ });
136
+
137
+ it("should throw when the predicate allows it", async () => {
138
+ mockRequest(request, { status: 400 });
139
+
140
+ render(
141
+ <ErrorBoundary>
142
+ <Page throwOnError={(error) => !!error} />
143
+ </ErrorBoundary>,
144
+ );
145
+
146
+ await waitFor(() => {
147
+ expect(screen.getByTestId("error-boundary")).toBeInTheDocument();
148
+ });
149
+ });
150
+
151
+ it("should throw only after the retries are finished", async () => {
152
+ request = createRequest().setRetry(2).setRetryTime(10);
153
+ mockRequest(request, { status: 500 });
154
+ const responseSpy = vi.fn();
155
+ const unmount = client.requestManager.events.onResponse(responseSpy);
156
+
157
+ render(
158
+ <ErrorBoundary>
159
+ <Page throwOnError />
160
+ </ErrorBoundary>,
161
+ );
162
+
163
+ await waitFor(() => {
164
+ expect(screen.getByTestId("error-boundary")).toBeInTheDocument();
165
+ });
166
+ expect(responseSpy).toHaveBeenCalledTimes(3);
167
+ unmount();
168
+ });
169
+
170
+ it("should fetch again after the error boundary reset", async () => {
171
+ mockRequest(request, { status: 400 });
172
+
173
+ render(
174
+ <ErrorBoundary>
175
+ <Page throwOnError />
176
+ </ErrorBoundary>,
177
+ );
178
+
179
+ await waitFor(() => {
180
+ expect(screen.getByTestId("error-boundary")).toBeInTheDocument();
181
+ });
182
+
183
+ const data = mockRequest(request, { data: { recovered: true } });
184
+ act(() => {
185
+ screen.getByTestId("error-boundary").click();
186
+ });
187
+
188
+ await waitFor(() => {
189
+ expect(screen.getByTestId("result").textContent).toBe(JSON.stringify(data));
190
+ });
191
+ });
192
+
193
+ it("should throw in suspense mode", async () => {
194
+ const error = mockRequest(request, { status: 400 });
195
+
196
+ function SuspensePage() {
197
+ const { data } = useFetch(request, { suspense: true, throwOnError: true });
198
+ return <div data-testid="result">{JSON.stringify(data)}</div>;
199
+ }
200
+
201
+ render(
202
+ <ErrorBoundary>
203
+ <Suspense fallback={<div data-testid="fallback" />}>
204
+ <SuspensePage />
205
+ </Suspense>
206
+ </ErrorBoundary>,
207
+ );
208
+
209
+ await waitFor(() => {
210
+ expect(screen.getByTestId("error-boundary").textContent).toBe(JSON.stringify(error));
211
+ });
212
+ });
213
+ });
@@ -1,6 +1,7 @@
1
1
  import { Client } from "@hyper-fetch/core";
2
2
  import { expectType, expectNotType, expectFunctionParametersType } from "@hyper-fetch/testing";
3
3
  import type { UseFetchReturnType } from "hooks/use-fetch";
4
+ import { useFetch } from "hooks/use-fetch";
4
5
 
5
6
  const client = new Client({
6
7
  url: "http://localhost:3000",
@@ -178,4 +179,44 @@ describe("useFetch [Types]", () => {
178
179
  expectType<() => void>().assert(bounce.reset);
179
180
  });
180
181
  });
182
+
183
+ describe("select", () => {
184
+ it("should infer the selected data type", () => {
185
+ const useSelected = () => useFetch(getUsers, { select: (users) => users.map((user) => user.name) });
186
+ const data = null as unknown as ReturnType<typeof useSelected>["data"];
187
+ const setData = null as unknown as ReturnType<typeof useSelected>["setData"];
188
+ expectType<string[] | null>().assert(data);
189
+ expectNotType<{ id: string; name: string }[] | null>().assert(data);
190
+ expectFunctionParametersType(setData).assert([["name"]]);
191
+ });
192
+
193
+ it("should type selector argument as the response", () => {
194
+ const useSelected = () =>
195
+ useFetch(getUser, {
196
+ select: (user) => {
197
+ expectType<{ id: string; name: string; email: string }>().assert(user);
198
+ return user.email;
199
+ },
200
+ });
201
+ const data = null as unknown as ReturnType<typeof useSelected>["data"];
202
+ expectType<string | null>().assert(data);
203
+ });
204
+
205
+ it("should keep the response type without selector", () => {
206
+ const useDefault = () => useFetch(getUsers, { structuralSharing: false });
207
+ const data = null as unknown as ReturnType<typeof useDefault>["data"];
208
+ expectType<{ id: string; name: string }[] | null>().assert(data);
209
+ });
210
+
211
+ it("should type throwOnError predicate with the request error", () => {
212
+ const useThrowing = () =>
213
+ useFetch(getUserWithError, {
214
+ throwOnError: (error) => {
215
+ expectType<{ code: number; message: string; details: string[] } | Error>().assert(error);
216
+ return true;
217
+ },
218
+ });
219
+ expectType<() => unknown>().assert(useThrowing);
220
+ });
221
+ });
181
222
  });