@hyper-fetch/react 9.6.1 → 9.7.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 (98) hide show
  1. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  2. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  3. package/__tests__/features/helpers/utils.spec.ts +127 -0
  4. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  5. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  6. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  7. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  8. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  9. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  10. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  11. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  12. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  13. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  14. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  15. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  16. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  17. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  18. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  19. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  20. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  21. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  22. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  23. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  24. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  25. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  26. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  27. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  28. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  29. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  30. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  31. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  32. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  33. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  34. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  35. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  36. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  37. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  38. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  39. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  40. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  41. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  42. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  43. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  44. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  45. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  46. package/__tests__/features/use-submit/use-submit.optimistic-helpers.spec.tsx +455 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  48. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  49. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  50. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  51. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  52. package/__tests__/utils/gate.utils.ts +103 -0
  53. package/__tests__/utils/gated-client.utils.ts +158 -0
  54. package/__tests__/utils/helpers.utils.ts +19 -0
  55. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  57. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  60. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  61. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  69. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  70. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-submit/use-submit.constants.d.ts +1 -1
  73. package/dist/hooks/use-submit/use-submit.constants.d.ts.map +1 -1
  74. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  75. package/dist/hooks/use-submit/use-submit.types.d.ts +6 -1
  76. package/dist/hooks/use-submit/use-submit.types.d.ts.map +1 -1
  77. package/dist/index.mjs +633 -346
  78. package/dist/index.mjs.map +1 -1
  79. package/dist/provider/provider.d.ts.map +1 -1
  80. package/package.json +1 -1
  81. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  82. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  83. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  84. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  85. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  86. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  87. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  88. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  89. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  90. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  91. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  92. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  93. package/src/hooks/use-submit/use-submit.constants.ts +3 -1
  94. package/src/hooks/use-submit/use-submit.hooks.ts +167 -53
  95. package/src/hooks/use-submit/use-submit.types.ts +6 -0
  96. package/src/provider/provider.tsx +9 -1
  97. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  98. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -541,7 +541,7 @@ describe("useTrackedState [ Actions ]", () => {
541
541
  expect(result.current[0].loading).toBe(false);
542
542
  expect(result.current[0].status).toBe(null);
543
543
  expect(result.current[0].success).toBe(false);
544
- expect(result.current[0].extra).toBe(null);
544
+ expect(result.current[0].extra).toStrictEqual(request.client.adapter.defaultExtra);
545
545
  expect(result.current[0].retries).toBe(0);
546
546
  expect(result.current[0].responseTimestamp).toBe(null);
547
547
  expect(result.current[0].requestTimestamp).toBe(null);
@@ -0,0 +1,294 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import type { UseTrackedStateProps } from "helpers";
3
+ import { getRequestIdentity, getShouldClearState, useRequestEvents, useTrackedState } from "helpers";
4
+ import { isEqual } from "utils";
5
+
6
+ import { client, createRequest } from "../../../utils";
7
+ import { setCacheResponse } from "../../../utils/gate.utils";
8
+
9
+ type Data = { value: number };
10
+
11
+ describe("useTrackedState [ Request Keys ]", () => {
12
+ const logger = client.loggerManager.initialize(client, "test");
13
+
14
+ const renderTracked = <T extends ReturnType<typeof createRequest<Data>>>(
15
+ initialRequest: T,
16
+ options?: Partial<UseTrackedStateProps<T>>,
17
+ ) => {
18
+ const renders: { key: string; data: unknown; loading: boolean }[] = [];
19
+ const view = renderHook(
20
+ ({ request }: { request: T }) => {
21
+ const tracked = useTrackedState<T>({
22
+ logger,
23
+ request,
24
+ dispatcher: client.fetchDispatcher,
25
+ initialResponse: null,
26
+ deepCompare: isEqual,
27
+ dependencyTracking: false,
28
+ ...options,
29
+ });
30
+ renders.push({ key: request.cacheKey, data: tracked[0].data, loading: tracked[0].loading });
31
+ return tracked;
32
+ },
33
+ { initialProps: { request: initialRequest } },
34
+ );
35
+ return { ...view, renders };
36
+ };
37
+
38
+ beforeEach(() => {
39
+ client.clear();
40
+ });
41
+
42
+ describe("given getRequestIdentity util", () => {
43
+ it("should be the same for requests differing only by query params", () => {
44
+ const request = createRequest({ endpoint: "/users" as any });
45
+
46
+ expect(getRequestIdentity(request.setQueryParams({ page: 1, sort_by: "a" }))).toBe(
47
+ getRequestIdentity(request.setQueryParams({ page: 2, sort_by: "b" })),
48
+ );
49
+ });
50
+ it("should differ for requests with different params", () => {
51
+ const request = createRequest({ endpoint: "/users/:id" as any });
52
+
53
+ expect(getRequestIdentity(request.setParams({ id: 1 } as any))).not.toBe(
54
+ getRequestIdentity(request.setParams({ id: 2 } as any)),
55
+ );
56
+ });
57
+ it("should differ for requests with different methods", () => {
58
+ expect(getRequestIdentity(createRequest({ method: "GET" }))).not.toBe(
59
+ getRequestIdentity(createRequest({ method: "POST" })),
60
+ );
61
+ });
62
+ it("should differ for requests with different scopes", () => {
63
+ const request = createRequest();
64
+
65
+ expect(getRequestIdentity(request.setScope("a"))).not.toBe(getRequestIdentity(request.setScope("b")));
66
+ expect(getRequestIdentity(request.setScope("a"))).not.toBe(getRequestIdentity(request));
67
+ });
68
+ });
69
+
70
+ describe("given getShouldClearState util", () => {
71
+ it("should never clear for the same key", () => {
72
+ expect(getShouldClearState("clean", "GET_/users_", "GET_/users_")).toBeFalse();
73
+ expect(getShouldClearState("auto", "GET_/users_", "GET_/users_")).toBeFalse();
74
+ expect(getShouldClearState("preserve", "GET_/users_", "GET_/users_")).toBeFalse();
75
+ });
76
+ it("should always clear in the clean mode", () => {
77
+ expect(getShouldClearState("clean", 'GET_/users_{"page":1}', 'GET_/users_{"page":2}')).toBeTrue();
78
+ });
79
+ it("should never clear in the preserve mode", () => {
80
+ expect(getShouldClearState("preserve", "GET_/users/1_", "GET_/users/2_")).toBeFalse();
81
+ });
82
+ it("should clear in the auto mode when the endpoint changes", () => {
83
+ expect(getShouldClearState("auto", "GET_/users/1_", "GET_/users/2_")).toBeTrue();
84
+ });
85
+ it("should not clear in the auto mode when only the query params change", () => {
86
+ expect(getShouldClearState("auto", 'GET_/users_{"page":1}', 'GET_/users_{"page":2}')).toBeFalse();
87
+ });
88
+ });
89
+
90
+ describe("when the request key changes", () => {
91
+ it("should switch the state during the render with the new key", () => {
92
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
93
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
94
+ const { rerender, renders } = renderTracked(request.setParams({ id: 1 }) as any);
95
+
96
+ rerender({ request: request.setParams({ id: 2 }) as any });
97
+
98
+ const rendersOfNewKey = renders.filter((render) => render.key === request.setParams({ id: 2 }).cacheKey);
99
+ expect(rendersOfNewKey.map((render) => render.data)).toStrictEqual(rendersOfNewKey.map(() => null));
100
+ });
101
+ it("should use the cache of the new key during the render with it", () => {
102
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
103
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
104
+ setCacheResponse(request.setParams({ id: 2 }), { value: 2 });
105
+ const { rerender, renders } = renderTracked(request.setParams({ id: 1 }) as any);
106
+
107
+ rerender({ request: request.setParams({ id: 2 }) as any });
108
+
109
+ const firstRenderOfNewKey = renders.find((render) => render.key === request.setParams({ id: 2 }).cacheKey);
110
+ expect(firstRenderOfNewKey?.data).toStrictEqual({ value: 2 });
111
+ });
112
+ it("should keep the state for the query params change in the auto mode", () => {
113
+ const request = createRequest<Data>();
114
+ setCacheResponse(request.setQueryParams({ page_number: 1 }), { value: 1 });
115
+ const { rerender, result } = renderTracked(request.setQueryParams({ page_number: 1 }) as any);
116
+
117
+ rerender({ request: request.setQueryParams({ page_number: 2 }) as any });
118
+
119
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
120
+ });
121
+ it("should clear the state for the query params change in the clean mode", () => {
122
+ const request = createRequest<Data>();
123
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
124
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
125
+ keepPreviousData: "clean",
126
+ });
127
+
128
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
129
+
130
+ expect(result.current[0].data).toBeNull();
131
+ });
132
+ it("should keep the state for the params change in the preserve mode", () => {
133
+ const request = createRequest<Data, any, "/items/:id">({ endpoint: "/items/:id" });
134
+ setCacheResponse(request.setParams({ id: 1 }), { value: 1 });
135
+ const { rerender, result } = renderTracked(request.setParams({ id: 1 }) as any, {
136
+ keepPreviousData: "preserve",
137
+ });
138
+
139
+ rerender({ request: request.setParams({ id: 2 }) as any });
140
+
141
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
142
+ });
143
+ it("should not replace the kept state with the initial response", () => {
144
+ const request = createRequest<Data>();
145
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
146
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
147
+ initialResponse: { data: { value: 0 } },
148
+ });
149
+
150
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
151
+
152
+ expect(result.current[0].data).toStrictEqual({ value: 1 });
153
+ });
154
+ it("should use the initial response for the cleared state", () => {
155
+ const request = createRequest<Data>();
156
+ setCacheResponse(request.setQueryParams({ page: 1 }), { value: 1 });
157
+ const { rerender, result } = renderTracked(request.setQueryParams({ page: 1 }) as any, {
158
+ initialResponse: { data: { value: 0 } },
159
+ keepPreviousData: "clean",
160
+ });
161
+
162
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
163
+
164
+ expect(result.current[0].data).toStrictEqual({ value: 0 });
165
+ });
166
+ });
167
+
168
+ describe("when actions are used", () => {
169
+ it("should keep the identity of the actions between renders", () => {
170
+ const request = createRequest<Data>();
171
+ const { rerender, result } = renderTracked(request as any);
172
+ const actions = result.current[1];
173
+
174
+ rerender({ request: request.setQueryParams({ page: 2 }) as any });
175
+
176
+ expect(result.current[1]).toBe(actions);
177
+ });
178
+ it("should pass the status 0 to the updater", () => {
179
+ const request = createRequest<Data>();
180
+ const { result } = renderTracked(request as any);
181
+ const updater = vi.fn((previous: number | null) => (previous === 0 ? 500 : 200));
182
+
183
+ act(() => {
184
+ result.current[1].setStatus(0 as any);
185
+ });
186
+ act(() => {
187
+ result.current[1].setStatus(updater as any);
188
+ });
189
+
190
+ expect(updater).toHaveBeenCalledExactlyOnceWith(0);
191
+ expect(result.current[0].status).toBe(500);
192
+ });
193
+ });
194
+
195
+ describe("when used with useRequestEvents", () => {
196
+ const renderEvents = (request: ReturnType<typeof createRequest<Data>>) => {
197
+ return renderHook(() => {
198
+ const [state, actions, { setCacheData, getIsDataProcessing }] = useTrackedState({
199
+ logger,
200
+ request,
201
+ dispatcher: client.fetchDispatcher,
202
+ initialResponse: null,
203
+ deepCompare: isEqual,
204
+ dependencyTracking: false,
205
+ });
206
+ const [callbacks, listeners] = useRequestEvents({
207
+ logger,
208
+ actions,
209
+ request,
210
+ dispatcher: client.fetchDispatcher,
211
+ setCacheData,
212
+ getIsDataProcessing,
213
+ });
214
+ return { state, callbacks, listeners };
215
+ });
216
+ };
217
+
218
+ it("should keep the identity of the callbacks between renders", () => {
219
+ const { result, rerender } = renderEvents(createRequest<Data>());
220
+ const { callbacks } = result.current;
221
+
222
+ rerender();
223
+
224
+ expect(result.current.callbacks).toBe(callbacks);
225
+ });
226
+ it("should receive the cache data of the listened request", () => {
227
+ const request = createRequest<Data>();
228
+ const { result } = renderEvents(request);
229
+
230
+ act(() => {
231
+ result.current.listeners.addCacheDataListener(request);
232
+ setCacheResponse(request, { value: 1 });
233
+ });
234
+
235
+ expect(result.current.state.data).toStrictEqual({ value: 1 });
236
+ });
237
+ it("should ignore the cache data of another scope", () => {
238
+ const request = createRequest<Data>();
239
+ const { result } = renderEvents(request);
240
+
241
+ act(() => {
242
+ result.current.listeners.addCacheDataListener(request);
243
+ setCacheResponse(request.setScope("other"), { value: 1 });
244
+ });
245
+
246
+ expect(result.current.state.data).toBeNull();
247
+ });
248
+ it("should receive the cache data of the request listened with a scope", () => {
249
+ const request = createRequest<Data>().setScope("mine");
250
+ const { result } = renderEvents(request);
251
+
252
+ act(() => {
253
+ result.current.listeners.addCacheDataListener(request);
254
+ setCacheResponse(request, { value: 1 });
255
+ });
256
+
257
+ expect(result.current.state.data).toStrictEqual({ value: 1 });
258
+ });
259
+ it("should follow the loading events of the scoped request", () => {
260
+ const request = createRequest<Data>().setScope("mine");
261
+ const { result } = renderEvents(request);
262
+
263
+ act(() => {
264
+ result.current.listeners.addCacheDataListener(request);
265
+ client.requestManager.events.emitLoading({
266
+ request,
267
+ requestId: "1",
268
+ loading: true,
269
+ isRetry: false,
270
+ isOffline: false,
271
+ });
272
+ });
273
+
274
+ expect(result.current.state.loading).toBeTrue();
275
+ });
276
+ it("should ignore the loading events of another scope", () => {
277
+ const request = createRequest<Data>();
278
+ const { result } = renderEvents(request.setScope("mine"));
279
+
280
+ act(() => {
281
+ result.current.listeners.addCacheDataListener(request.setScope("mine"));
282
+ client.requestManager.events.emitLoading({
283
+ request: request.setScope("other"),
284
+ requestId: "1",
285
+ loading: true,
286
+ isRetry: false,
287
+ isOffline: false,
288
+ });
289
+ });
290
+
291
+ expect(result.current.state.loading).toBeFalse();
292
+ });
293
+ });
294
+ });
@@ -0,0 +1,127 @@
1
+ import { createTrackedProxy, getBounceData, isEmpty, isEqual } from "utils";
2
+
3
+ describe("Utils", () => {
4
+ describe("given createTrackedProxy util", () => {
5
+ const createProxy = () => {
6
+ const tracked = vi.fn();
7
+ const proxy = createTrackedProxy(
8
+ { data: 1, loading: false, refetch: () => "called" },
9
+ ["data", "loading"],
10
+ tracked,
11
+ );
12
+ return { proxy, tracked };
13
+ };
14
+
15
+ it("should return the values of the target", () => {
16
+ const { proxy } = createProxy();
17
+
18
+ expect(proxy.data).toBe(1);
19
+ expect(proxy.loading).toBeFalse();
20
+ expect(proxy.refetch()).toBe("called");
21
+ });
22
+ it("should report only the tracked keys that were read", () => {
23
+ const { proxy, tracked } = createProxy();
24
+
25
+ expect(proxy.data).toBe(1);
26
+ expect(proxy.refetch).toBeFunction();
27
+
28
+ expect(tracked.mock.calls).toStrictEqual([["data"]]);
29
+ });
30
+ it("should report nothing when nothing is read", () => {
31
+ const { tracked } = createProxy();
32
+
33
+ expect(tracked).not.toHaveBeenCalled();
34
+ });
35
+ it("should report every tracked key on destructuring with the rest", () => {
36
+ const { proxy, tracked } = createProxy();
37
+
38
+ const { ...rest } = proxy;
39
+
40
+ expect(rest.data).toBe(1);
41
+ expect(tracked.mock.calls.flat().toSorted()).toStrictEqual(["data", "loading"]);
42
+ });
43
+ it("should keep the keys enumerable", () => {
44
+ const { proxy } = createProxy();
45
+
46
+ expect(Object.keys(proxy)).toStrictEqual(["data", "loading", "refetch"]);
47
+ });
48
+ it("should not report symbol reads", () => {
49
+ const { proxy, tracked } = createProxy();
50
+
51
+ expect((proxy as Record<symbol, unknown>)[Symbol.toStringTag]).toBeUndefined();
52
+ expect(tracked).not.toHaveBeenCalled();
53
+ });
54
+ });
55
+
56
+ describe("given getBounceData util", () => {
57
+ it("should expose only the state and reset", () => {
58
+ const reset = vi.fn();
59
+ const bounce = getBounceData({ active: true, reset, debounce: vi.fn(), throttle: vi.fn() } as any);
60
+
61
+ expect(bounce.active).toBeTrue();
62
+ expect(bounce.reset).toBe(reset);
63
+ expect((bounce as Record<string, unknown>).debounce).toBeUndefined();
64
+ expect((bounce as Record<string, unknown>).throttle).toBeUndefined();
65
+ });
66
+ });
67
+
68
+ describe("given isEqual util", () => {
69
+ it.each([
70
+ [1, 1],
71
+ ["a", "a"],
72
+ [null, null],
73
+ [undefined, undefined],
74
+ [Number.NaN, Number.NaN],
75
+ [[], []],
76
+ [{}, {}],
77
+ [
78
+ [1, [2, { a: 3 }]],
79
+ [1, [2, { a: 3 }]],
80
+ ],
81
+ [{ a: { b: { c: [1, 2] } } }, { a: { b: { c: [1, 2] } } }],
82
+ [new Date(1000), new Date(1000)],
83
+ [{ a: undefined }, { a: undefined }],
84
+ ])("should treat %j and %j as equal", (first, second) => {
85
+ expect(isEqual(first, second)).toBeTrue();
86
+ });
87
+ it.each([
88
+ [1, 2],
89
+ [1, "1"],
90
+ [null, undefined],
91
+ [null, {}],
92
+ [[], {}],
93
+ [
94
+ [1, 2],
95
+ [2, 1],
96
+ ],
97
+ [[1], [1, 2]],
98
+ [{ a: 1 }, { a: 2 }],
99
+ [{ a: 1 }, { b: 1 }],
100
+ [{ a: 1 }, { a: 1, b: 2 }],
101
+ [{ a: { b: 1 } }, { a: { b: 2 } }],
102
+ [new Date(1000), new Date(2000)],
103
+ [0, false],
104
+ ["", null],
105
+ ])("should treat %j and %j as different", (first, second) => {
106
+ expect(isEqual(first, second)).toBeFalse();
107
+ });
108
+ it("should compare functions by reference", () => {
109
+ const callback = () => null;
110
+
111
+ expect(isEqual(callback, callback)).toBeTrue();
112
+ expect(isEqual(callback, () => null)).toBeFalse();
113
+ });
114
+ });
115
+
116
+ describe("given isEmpty util", () => {
117
+ it.each([[[]], [{}]])("should treat %j as empty", (value) => {
118
+ expect(isEmpty(value)).toBeTrue();
119
+ });
120
+ it.each([[[1]], [{ a: 1 }], [null], [undefined], [0], [""], [new Date()]])(
121
+ "should not treat %j as empty",
122
+ (value) => {
123
+ expect(isEmpty(value)).toBeFalse();
124
+ },
125
+ );
126
+ });
127
+ });
@@ -0,0 +1,172 @@
1
+ import { act, render, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+ import type { ProviderOptionsType, ProviderValueType } from "provider";
4
+ import { Provider, useProvider } from "provider";
5
+ import type { ReactNode } from "react";
6
+ import { memo } from "react";
7
+
8
+ import { client, createRequest } from "../../utils";
9
+ import { advance, gateRequest } from "../../utils/gate.utils";
10
+
11
+ describe("Provider [ Config ]", () => {
12
+ let values: ProviderValueType | undefined;
13
+ let consumerRenders = 0;
14
+
15
+ const Consumer = memo(() => {
16
+ values = useProvider();
17
+ consumerRenders += 1;
18
+ return null;
19
+ });
20
+
21
+ const App = ({ config }: { config?: ProviderOptionsType }) => (
22
+ <Provider config={config}>
23
+ <Consumer />
24
+ </Provider>
25
+ );
26
+
27
+ beforeEach(() => {
28
+ vi.useFakeTimers();
29
+ client.clear();
30
+ values = undefined;
31
+ consumerRenders = 0;
32
+ });
33
+
34
+ afterEach(() => {
35
+ vi.useRealTimers();
36
+ });
37
+
38
+ describe("when the config prop is passed", () => {
39
+ it("should expose the config", () => {
40
+ render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
41
+
42
+ expect(values?.config).toStrictEqual({ useFetchConfig: { bounceTime: 1 } });
43
+ });
44
+ it("should expose an empty config without the prop", () => {
45
+ render(<App />);
46
+
47
+ expect(values?.config).toStrictEqual({});
48
+ });
49
+ it("should follow the changes of the config prop", () => {
50
+ const view = render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
51
+
52
+ view.rerender(<App config={{ useFetchConfig: { bounceTime: 2 } }} />);
53
+
54
+ expect(values?.config).toStrictEqual({ useFetchConfig: { bounceTime: 2 } });
55
+ });
56
+ it("should reset the config when the prop gets removed", () => {
57
+ const view = render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
58
+
59
+ view.rerender(<App />);
60
+
61
+ expect(values?.config).toStrictEqual({});
62
+ });
63
+ it("should not rerender consumers when an equal inline config is passed again", () => {
64
+ const view = render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
65
+ const { config } = values as ProviderValueType;
66
+
67
+ view.rerender(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
68
+ view.rerender(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
69
+
70
+ expect(values?.config).toBe(config);
71
+ expect(consumerRenders).toBe(1);
72
+ });
73
+ it("should keep the config set with setConfig while the prop stays the same", () => {
74
+ const view = render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
75
+
76
+ act(() => {
77
+ values?.setConfig({ useFetchConfig: { bounceTime: 50 } });
78
+ });
79
+ view.rerender(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
80
+
81
+ expect(values?.config).toStrictEqual({ useFetchConfig: { bounceTime: 50 } });
82
+ });
83
+ it("should replace the config set with setConfig when the prop changes", () => {
84
+ const view = render(<App config={{ useFetchConfig: { bounceTime: 1 } }} />);
85
+
86
+ act(() => {
87
+ values?.setConfig({ useFetchConfig: { bounceTime: 50 } });
88
+ });
89
+ view.rerender(<App config={{ useFetchConfig: { bounceTime: 2 } }} />);
90
+
91
+ expect(values?.config).toStrictEqual({ useFetchConfig: { bounceTime: 2 } });
92
+ });
93
+ });
94
+
95
+ describe("when hooks read the config", () => {
96
+ const createWrapper = (config: ProviderOptionsType) => {
97
+ return ({ children }: { children: ReactNode }) => <Provider config={config}>{children}</Provider>;
98
+ };
99
+
100
+ it("should apply the useFetch config to the hook", async () => {
101
+ const request = createRequest();
102
+ const calls = gateRequest(request);
103
+ const { result } = renderHook(() => useFetch(request).loading, {
104
+ wrapper: createWrapper({ useFetchConfig: { disabled: true } }),
105
+ });
106
+ await advance();
107
+
108
+ expect(calls).toHaveLength(0);
109
+ expect(result.current).toBeFalse();
110
+ });
111
+ it("should prefer the hook options over the config", async () => {
112
+ const request = createRequest();
113
+ const calls = gateRequest(request);
114
+ renderHook(() => useFetch(request, { disabled: false }).loading, {
115
+ wrapper: createWrapper({ useFetchConfig: { disabled: true } }),
116
+ });
117
+ await advance();
118
+
119
+ expect(calls).toHaveLength(1);
120
+ });
121
+ it("should use the default options without the provider", async () => {
122
+ const request = createRequest();
123
+ const calls = gateRequest(request);
124
+ renderHook(() => useFetch(request).loading);
125
+ await advance();
126
+
127
+ expect(calls).toHaveLength(1);
128
+ });
129
+ it("should apply the config changed with the prop to the mounted hook", async () => {
130
+ const request = createRequest();
131
+ const calls = gateRequest(request);
132
+ const Page = () => {
133
+ const { loading } = useFetch(request);
134
+ return <div>{String(loading)}</div>;
135
+ };
136
+ const view = render(
137
+ <Provider config={{ useFetchConfig: { disabled: true } }}>
138
+ <Page />
139
+ </Provider>,
140
+ );
141
+ await advance();
142
+ expect(calls).toHaveLength(0);
143
+
144
+ view.rerender(
145
+ <Provider config={{ useFetchConfig: { disabled: false } }}>
146
+ <Page />
147
+ </Provider>,
148
+ );
149
+ await advance();
150
+
151
+ expect(calls).toHaveLength(1);
152
+ });
153
+ it("should use the closest provider", async () => {
154
+ const request = createRequest();
155
+ const calls = gateRequest(request);
156
+ const Page = () => {
157
+ const { loading } = useFetch(request);
158
+ return <div>{String(loading)}</div>;
159
+ };
160
+ render(
161
+ <Provider config={{ useFetchConfig: { disabled: false } }}>
162
+ <Provider config={{ useFetchConfig: { disabled: true } }}>
163
+ <Page />
164
+ </Provider>
165
+ </Provider>,
166
+ );
167
+ await advance();
168
+
169
+ expect(calls).toHaveLength(0);
170
+ });
171
+ });
172
+ });