@hyper-fetch/react 9.6.1 → 9.6.2

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 (91) 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-settlement.spec.ts +6 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  48. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  49. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  50. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  51. package/__tests__/utils/gate.utils.ts +103 -0
  52. package/__tests__/utils/gated-client.utils.ts +158 -0
  53. package/__tests__/utils/helpers.utils.ts +19 -0
  54. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  55. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  57. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  60. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  61. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  69. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  70. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  72. package/dist/index.mjs +630 -346
  73. package/dist/index.mjs.map +1 -1
  74. package/dist/provider/provider.d.ts.map +1 -1
  75. package/package.json +1 -1
  76. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  77. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  78. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  79. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  80. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  81. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  82. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  83. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  84. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  85. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  86. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  87. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  88. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  89. package/src/provider/provider.tsx +9 -1
  90. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  91. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,417 @@
1
+ import { Socket } from "@hyper-fetch/sockets";
2
+ import { act, render, renderHook, screen } from "@testing-library/react";
3
+ import { useEmitter } from "hooks/use-emitter";
4
+ import React, { StrictMode, useEffect } from "react";
5
+ import { expectTypeOf } from "vitest";
6
+
7
+ import type { ControlledWebSocket } from "../../../../sockets/__tests__/utils/controlled-websocket";
8
+ import {
9
+ ControlledWebSocket as Transport,
10
+ flushPromises,
11
+ installControlledWebSocket,
12
+ openWebSocket,
13
+ uninstallControlledWebSocket,
14
+ } from "../../../../sockets/__tests__/utils/controlled-websocket";
15
+
16
+ type Message = { text: string };
17
+
18
+ describe("useEmitter [ Lifecycle ]", () => {
19
+ let socket: Socket;
20
+ let websocket: ControlledWebSocket;
21
+ let emitter: ReturnType<typeof createEmitter>;
22
+ const sockets: Socket[] = [];
23
+
24
+ const createSocket = (url = "ws://use-emitter", autoConnect = true) => {
25
+ const instance = new Socket({ url, reconnectTime: 100, adapterOptions: { autoConnect } });
26
+ sockets.push(instance);
27
+ return instance;
28
+ };
29
+
30
+ const createEmitter = (instance: Socket = socket) => {
31
+ return instance.createEmitter<Message>()({ topic: "chat/:roomId" });
32
+ };
33
+
34
+ beforeEach(async () => {
35
+ installControlledWebSocket();
36
+ socket = createSocket();
37
+ websocket = await openWebSocket();
38
+ emitter = createEmitter();
39
+ });
40
+
41
+ afterEach(async () => {
42
+ await Promise.all(sockets.map((instance) => instance.disconnect()));
43
+ sockets.length = 0;
44
+ uninstallControlledWebSocket();
45
+ });
46
+
47
+ describe("When emitting", () => {
48
+ it("should send the message with the payload and params passed to emit", async () => {
49
+ const view = renderHook(() => useEmitter(emitter));
50
+
51
+ await act(async () => {
52
+ view.result.current.emit({ payload: { text: "hi" }, params: { roomId: 1 } });
53
+ await flushPromises();
54
+ });
55
+
56
+ expect(websocket.sentMessages).toStrictEqual([{ topic: "chat/1", data: { text: "hi" } }]);
57
+ });
58
+
59
+ it("should send the payload prepared on the emitter", async () => {
60
+ const view = renderHook(() => useEmitter(emitter.setParams({ roomId: 1 }).setPayload({ text: "prepared" })));
61
+
62
+ await act(async () => {
63
+ view.result.current.emit();
64
+ await flushPromises();
65
+ });
66
+
67
+ expect(websocket.sentMessages).toStrictEqual([{ topic: "chat/1", data: { text: "prepared" } }]);
68
+ });
69
+
70
+ it("should emit from an event handler", async () => {
71
+ const Component = () => {
72
+ const { emit } = useEmitter(emitter.setParams({ roomId: 1 }));
73
+ return (
74
+ <button type="button" onClick={() => emit({ payload: { text: "clicked" } })}>
75
+ send
76
+ </button>
77
+ );
78
+ };
79
+ render(<Component />);
80
+
81
+ await act(async () => {
82
+ screen.getByText("send").click();
83
+ screen.getByText("send").click();
84
+ await flushPromises();
85
+ });
86
+
87
+ expect(websocket.sentMessages).toStrictEqual([
88
+ { topic: "chat/1", data: { text: "clicked" } },
89
+ { topic: "chat/1", data: { text: "clicked" } },
90
+ ]);
91
+ });
92
+
93
+ it("should emit from an effect", async () => {
94
+ const Component = () => {
95
+ const { emit } = useEmitter(emitter.setParams({ roomId: 1 }));
96
+ useEffect(() => {
97
+ emit({ payload: { text: "mounted" } });
98
+ // eslint-disable-next-line react-hooks/exhaustive-deps
99
+ }, []);
100
+ return null;
101
+ };
102
+
103
+ await act(async () => {
104
+ render(<Component />);
105
+ await flushPromises();
106
+ });
107
+
108
+ expect(websocket.sentMessages).toStrictEqual([{ topic: "chat/1", data: { text: "mounted" } }]);
109
+ });
110
+
111
+ it("should keep the order of messages emitted in one handler", async () => {
112
+ const view = renderHook(() => useEmitter(emitter.setParams({ roomId: 1 })));
113
+
114
+ await act(async () => {
115
+ for (let i = 0; i < 20; i += 1) {
116
+ view.result.current.emit({ payload: { text: String(i) } });
117
+ }
118
+ await flushPromises();
119
+ });
120
+
121
+ expect(websocket.sentMessages.map((message) => (message.data as Message).text)).toStrictEqual(
122
+ Array.from({ length: 20 }, (_, index) => String(index)),
123
+ );
124
+ });
125
+
126
+ it("should type the emit options by the emitter", () => {
127
+ const view = renderHook(() => useEmitter(emitter));
128
+
129
+ expectTypeOf(view.result.current.emit).toBeCallableWith({ payload: { text: "hi" }, params: { roomId: 1 } });
130
+ expectTypeOf(view.result.current.connected).toEqualTypeOf<boolean>();
131
+ expectTypeOf(view.result.current.connecting).toEqualTypeOf<boolean>();
132
+ // @ts-expect-error - payload has a wrong shape
133
+ expectTypeOf(view.result.current.emit).toBeCallableWith({ payload: { text: 1 }, params: { roomId: 1 } });
134
+ });
135
+ });
136
+
137
+ describe("When using the emit callbacks", () => {
138
+ it("should call onEmit when a message is sent", async () => {
139
+ const spy = vi.fn();
140
+ const view = renderHook(() => {
141
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
142
+ hook.onEmit(spy);
143
+ return hook;
144
+ });
145
+
146
+ await act(async () => {
147
+ view.result.current.emit({ payload: { text: "hi" } });
148
+ await flushPromises();
149
+ });
150
+
151
+ expect(spy).toHaveBeenCalledTimes(1);
152
+ });
153
+
154
+ it("should call the latest onEmit callback", async () => {
155
+ const calls: string[] = [];
156
+ const view = renderHook(
157
+ ({ label }: { label: string }) => {
158
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
159
+ hook.onEmit(() => calls.push(label));
160
+ return hook;
161
+ },
162
+ { initialProps: { label: "first-render" } },
163
+ );
164
+
165
+ await act(async () => {
166
+ view.result.current.emit({ payload: { text: "a" } });
167
+ await flushPromises();
168
+ });
169
+ view.rerender({ label: "second-render" });
170
+ await act(async () => {
171
+ view.result.current.emit({ payload: { text: "b" } });
172
+ await flushPromises();
173
+ });
174
+
175
+ expect(calls).toStrictEqual(["first-render", "second-render"]);
176
+ });
177
+
178
+ it("should not call onEmit for other topics", async () => {
179
+ const spy = vi.fn();
180
+ renderHook(() => {
181
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
182
+ hook.onEmit(spy);
183
+ return hook;
184
+ });
185
+
186
+ await act(async () => {
187
+ emitter.emit({ payload: { text: "other room" }, params: { roomId: 2 } });
188
+ await flushPromises();
189
+ });
190
+
191
+ expect(spy).not.toHaveBeenCalled();
192
+ });
193
+
194
+ it("should call onEmitError when the message is emitted while disconnected", async () => {
195
+ const errors: string[] = [];
196
+ const view = renderHook(() => {
197
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
198
+ hook.onEmitError(({ error }) => errors.push(error.message));
199
+ return hook;
200
+ });
201
+ await act(async () => {
202
+ await socket.disconnect();
203
+ });
204
+
205
+ await act(async () => {
206
+ view.result.current.emit({ payload: { text: "lost" } });
207
+ await flushPromises();
208
+ });
209
+
210
+ expect(errors).toStrictEqual(["Cannot emit event when connection is not open"]);
211
+ expect(websocket.sent).toStrictEqual([]);
212
+ });
213
+
214
+ it("should call onEmitError when the transport fails to send", async () => {
215
+ const errors: string[] = [];
216
+ const view = renderHook(() => {
217
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
218
+ hook.onEmitError(({ error }) => errors.push(error.message));
219
+ return hook;
220
+ });
221
+ socket.onError(() => null);
222
+ websocket.send = () => {
223
+ throw new Error("Buffer is full");
224
+ };
225
+
226
+ await act(async () => {
227
+ view.result.current.emit({ payload: { text: "lost" } });
228
+ await flushPromises();
229
+ });
230
+
231
+ expect(errors).toStrictEqual(["Buffer is full"]);
232
+ });
233
+
234
+ it("should not call the callbacks after unmount", async () => {
235
+ const onEmit = vi.fn();
236
+ const onEmitError = vi.fn();
237
+ const before = socket.emitter.eventNames().length;
238
+ const view = renderHook(() => {
239
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
240
+ hook.onEmit(onEmit);
241
+ hook.onEmitError(onEmitError);
242
+ return hook;
243
+ });
244
+
245
+ view.unmount();
246
+ await act(async () => {
247
+ emitter.emit({ payload: { text: "after unmount" }, params: { roomId: 1 } });
248
+ await flushPromises();
249
+ });
250
+
251
+ expect(onEmit).not.toHaveBeenCalled();
252
+ expect(onEmitError).not.toHaveBeenCalled();
253
+ expect(socket.emitter.eventNames()).toHaveLength(before);
254
+ });
255
+ });
256
+
257
+ describe("When the emitter changes", () => {
258
+ it("should follow the topic of the new emitter", async () => {
259
+ const spy = vi.fn();
260
+ const view = renderHook(
261
+ ({ roomId }: { roomId: number }) => {
262
+ const hook = useEmitter(emitter.setParams({ roomId }));
263
+ hook.onEmit(spy);
264
+ return hook;
265
+ },
266
+ { initialProps: { roomId: 1 } },
267
+ );
268
+ view.rerender({ roomId: 2 });
269
+
270
+ await act(async () => {
271
+ emitter.emit({ payload: { text: "old room" }, params: { roomId: 1 } });
272
+ await flushPromises();
273
+ });
274
+ expect(spy).not.toHaveBeenCalled();
275
+
276
+ await act(async () => {
277
+ view.result.current.emit({ payload: { text: "new room" } });
278
+ await flushPromises();
279
+ });
280
+ expect(spy).toHaveBeenCalledTimes(1);
281
+ expect(websocket.sentMessages.at(-1)).toStrictEqual({ topic: "chat/2", data: { text: "new room" } });
282
+ });
283
+
284
+ it("should follow an emitter of another socket with the same topic", async () => {
285
+ const otherSocket = createSocket("ws://other-socket");
286
+ const otherWebsocket = await openWebSocket(2);
287
+ const otherEmitter = createEmitter(otherSocket);
288
+ const spy = vi.fn();
289
+ const view = renderHook(
290
+ ({ current }: { current: typeof emitter }) => {
291
+ const hook = useEmitter(current.setParams({ roomId: 1 }));
292
+ hook.onEmit(spy);
293
+ return hook;
294
+ },
295
+ { initialProps: { current: emitter } },
296
+ );
297
+ view.rerender({ current: otherEmitter });
298
+
299
+ await act(async () => {
300
+ view.result.current.emit({ payload: { text: "new socket" } });
301
+ await flushPromises();
302
+ });
303
+
304
+ expect(otherWebsocket.sentMessages).toStrictEqual([{ topic: "chat/1", data: { text: "new socket" } }]);
305
+ expect(websocket.sent).toStrictEqual([]);
306
+ expect(spy).toHaveBeenCalledTimes(1);
307
+ });
308
+ });
309
+
310
+ describe("When rendered in StrictMode", () => {
311
+ const wrapper = ({ children }: { children: React.ReactNode }) => <StrictMode>{children}</StrictMode>;
312
+
313
+ it("should call onEmit once per message", async () => {
314
+ const spy = vi.fn();
315
+ const view = renderHook(
316
+ () => {
317
+ const hook = useEmitter(emitter.setParams({ roomId: 1 }));
318
+ hook.onEmit(spy);
319
+ return hook;
320
+ },
321
+ { wrapper },
322
+ );
323
+
324
+ await act(async () => {
325
+ view.result.current.emit({ payload: { text: "once" } });
326
+ await flushPromises();
327
+ });
328
+
329
+ expect(spy).toHaveBeenCalledTimes(1);
330
+ expect(websocket.sentMessages).toHaveLength(1);
331
+ });
332
+
333
+ it("should report the connection state and leave nothing behind after unmount", async () => {
334
+ const before = socket.emitter.eventNames().length;
335
+ const view = renderHook(() => useEmitter(emitter.setParams({ roomId: 1 }), { dependencyTracking: false }), {
336
+ wrapper,
337
+ });
338
+
339
+ expect(view.result.current.connected).toBeTrue();
340
+ await act(async () => {
341
+ await socket.disconnect();
342
+ });
343
+ expect(view.result.current.connected).toBeFalse();
344
+
345
+ view.unmount();
346
+ expect(socket.emitter.eventNames()).toHaveLength(before);
347
+ });
348
+ });
349
+
350
+ describe("When the connection state changes", () => {
351
+ it("should follow connecting, connected and disconnected", async () => {
352
+ const lazy = createSocket("ws://lazy");
353
+ await flushPromises();
354
+ const lazyEmitter = lazy.createEmitter<Message>()({ topic: "chat" });
355
+ const view = renderHook(() => useEmitter(lazyEmitter, { dependencyTracking: false }));
356
+
357
+ expect(view.result.current.connecting).toBeTrue();
358
+ expect(view.result.current.connected).toBeFalse();
359
+
360
+ act(() => {
361
+ Transport.last.serverOpen();
362
+ });
363
+ expect(view.result.current.connecting).toBeFalse();
364
+ expect(view.result.current.connected).toBeTrue();
365
+
366
+ act(() => {
367
+ Transport.last.serverClose({ code: 1000, wasClean: true });
368
+ });
369
+ expect(view.result.current.connected).toBeFalse();
370
+ });
371
+
372
+ it("should share the connection state between hooks of one socket", async () => {
373
+ const first = renderHook(() => useEmitter(emitter.setParams({ roomId: 1 }), { dependencyTracking: false }));
374
+ const second = renderHook(() => useEmitter(emitter.setParams({ roomId: 2 }), { dependencyTracking: false }));
375
+
376
+ await act(async () => {
377
+ await socket.disconnect();
378
+ });
379
+
380
+ expect(first.result.current.connected).toBeFalse();
381
+ expect(second.result.current.connected).toBeFalse();
382
+ });
383
+
384
+ it("should not re-render for connection changes the component does not read", async () => {
385
+ const renders = vi.fn();
386
+ renderHook(() => {
387
+ renders();
388
+ return useEmitter(emitter.setParams({ roomId: 1 })).emit;
389
+ });
390
+ renders.mockClear();
391
+
392
+ await act(async () => {
393
+ await socket.disconnect();
394
+ });
395
+
396
+ expect(renders).not.toHaveBeenCalled();
397
+ });
398
+
399
+ it("should call the latest connection callbacks", async () => {
400
+ const calls: string[] = [];
401
+ renderHook(() => {
402
+ const { onConnected, onDisconnected, onReconnecting } = useEmitter(emitter.setParams({ roomId: 1 }));
403
+ onConnected(() => calls.push("connected"));
404
+ onDisconnected(() => calls.push("disconnected"));
405
+ onReconnecting(({ attempts }) => calls.push(`reconnecting:${attempts}`));
406
+ });
407
+
408
+ await act(async () => {
409
+ const reconnecting = socket.reconnect();
410
+ await openWebSocket(2);
411
+ await reconnecting;
412
+ });
413
+
414
+ expect(calls).toStrictEqual(["reconnecting:0", "disconnected", "connected"]);
415
+ });
416
+ });
417
+ });
@@ -0,0 +1,199 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import type { UseFetchOptionsType } from "hooks/use-fetch";
3
+ import { useFetch } from "hooks/use-fetch";
4
+
5
+ import { client, createRequest } from "../../utils";
6
+ import { advance, gateRequest, settle } from "../../utils/gate.utils";
7
+
8
+ type Data = { search: string };
9
+ type Options = UseFetchOptionsType<ReturnType<typeof createRequest<Data>>>;
10
+
11
+ const bounceTime = 1000;
12
+
13
+ describe("useFetch [ Bounce Timers ]", () => {
14
+ let request = createRequest<Data>();
15
+ let calls = gateRequest(request);
16
+
17
+ const renderSearch = (options: Options) => {
18
+ return renderHook(
19
+ ({ search, ...rest }: { search: string } & Options) => {
20
+ const { data, bounce } = useFetch(request.setQueryParams({ search }), { ...options, ...rest } as never);
21
+ return { data, active: bounce.active, reset: bounce.reset };
22
+ },
23
+ { initialProps: { search: "a" } as { search: string } & Options },
24
+ );
25
+ };
26
+
27
+ const searches = () => calls.map((call) => call.request.queryParams.search);
28
+
29
+ beforeEach(() => {
30
+ vi.useFakeTimers();
31
+ client.clear();
32
+ request = createRequest<Data>();
33
+ calls = gateRequest(request);
34
+ });
35
+
36
+ afterEach(() => {
37
+ vi.useRealTimers();
38
+ });
39
+
40
+ describe("when debounce is used", () => {
41
+ const options: Options = { bounce: true, bounceType: "debounce", bounceTime };
42
+
43
+ it("should send the initial request right away", async () => {
44
+ renderSearch(options);
45
+ await advance();
46
+
47
+ expect(searches()).toStrictEqual(["a"]);
48
+ });
49
+ it("should wait with the request for the changed key", async () => {
50
+ const { rerender } = renderSearch(options);
51
+ await advance();
52
+
53
+ rerender({ search: "ab" });
54
+ await advance(bounceTime - 1);
55
+ expect(searches()).toStrictEqual(["a"]);
56
+
57
+ await advance(1);
58
+ expect(searches()).toStrictEqual(["a", "ab"]);
59
+ });
60
+ it("should send a single request for the last of the quick changes", async () => {
61
+ const { rerender } = renderSearch(options);
62
+ await advance();
63
+
64
+ for (const search of ["ab", "abc", "abcd", "abcde"]) {
65
+ rerender({ search });
66
+ // eslint-disable-next-line no-await-in-loop
67
+ await advance(bounceTime / 2);
68
+ }
69
+ await advance(bounceTime);
70
+
71
+ expect(searches()).toStrictEqual(["a", "abcde"]);
72
+ });
73
+ it("should expose the active state while waiting", async () => {
74
+ const { rerender, result } = renderSearch(options);
75
+ await advance();
76
+ expect(result.current.active).toBeFalse();
77
+
78
+ rerender({ search: "ab" });
79
+ expect(result.current.active).toBeTrue();
80
+
81
+ await advance(bounceTime);
82
+ expect(result.current.active).toBeFalse();
83
+ });
84
+ it("should cancel the waiting request with reset", async () => {
85
+ const { rerender, result } = renderSearch(options);
86
+ await advance();
87
+
88
+ rerender({ search: "ab" });
89
+ act(() => {
90
+ result.current.reset();
91
+ });
92
+ await advance(bounceTime * 2);
93
+
94
+ expect(searches()).toStrictEqual(["a"]);
95
+ });
96
+ it("should not send the waiting request after unmount", async () => {
97
+ const { rerender, unmount } = renderSearch(options);
98
+ await advance();
99
+
100
+ rerender({ search: "ab" });
101
+ unmount();
102
+ await advance(bounceTime * 2);
103
+
104
+ expect(searches()).toStrictEqual(["a"]);
105
+ });
106
+ it("should not send the waiting request when the hook gets disabled", async () => {
107
+ const { rerender } = renderSearch(options);
108
+ await advance();
109
+
110
+ rerender({ search: "ab" });
111
+ rerender({ search: "ab", disabled: true });
112
+ await advance(bounceTime * 2);
113
+
114
+ expect(searches()).toStrictEqual(["a"]);
115
+ });
116
+ it("should debounce the dependencies changes", async () => {
117
+ const { rerender } = renderSearch({ ...options, dependencies: [0] });
118
+ await advance();
119
+ calls[0].succeed({ search: "a" });
120
+ await settle();
121
+
122
+ rerender({ search: "a", dependencies: [1] });
123
+ rerender({ search: "a", dependencies: [2] });
124
+ await advance(bounceTime - 1);
125
+ expect(calls).toHaveLength(1);
126
+
127
+ await advance(1);
128
+ expect(calls).toHaveLength(2);
129
+ });
130
+ it("should show the data of the debounced request", async () => {
131
+ const { rerender, result } = renderSearch(options);
132
+ await advance();
133
+ calls[0].succeed({ search: "a" });
134
+ await settle();
135
+
136
+ rerender({ search: "ab" });
137
+ await advance(bounceTime);
138
+ calls[1].succeed({ search: "ab" });
139
+ await settle();
140
+
141
+ expect(result.current.data).toStrictEqual({ search: "ab" });
142
+ });
143
+ it("should not debounce the changes without the bounce option", async () => {
144
+ const { rerender } = renderSearch({ bounce: false, bounceTime });
145
+ await advance();
146
+
147
+ rerender({ search: "ab" });
148
+ await advance();
149
+
150
+ expect(searches()).toStrictEqual(["a", "ab"]);
151
+ });
152
+ });
153
+
154
+ describe("when throttle is used", () => {
155
+ const options: Options = { bounce: true, bounceType: "throttle", bounceTime, bounceTimeout: bounceTime };
156
+
157
+ it("should send the initial request right away", async () => {
158
+ renderSearch(options);
159
+ await advance();
160
+
161
+ expect(searches()).toStrictEqual(["a"]);
162
+ });
163
+ it("should send the first change right away", async () => {
164
+ const { rerender } = renderSearch(options);
165
+ await advance();
166
+
167
+ rerender({ search: "ab" });
168
+ await advance();
169
+
170
+ expect(searches()).toStrictEqual(["a", "ab"]);
171
+ });
172
+ it("should hold the changes made during the throttle interval and send the last one", async () => {
173
+ const { rerender } = renderSearch(options);
174
+ await advance();
175
+ rerender({ search: "ab" });
176
+ await advance();
177
+
178
+ rerender({ search: "abc" });
179
+ rerender({ search: "abcd" });
180
+ await advance(bounceTime - 1);
181
+ expect(searches()).toStrictEqual(["a", "ab"]);
182
+
183
+ await advance(1);
184
+ expect(searches()).toStrictEqual(["a", "ab", "abcd"]);
185
+ });
186
+ it("should not send the held request after unmount", async () => {
187
+ const { rerender, unmount } = renderSearch(options);
188
+ await advance();
189
+ rerender({ search: "ab" });
190
+ await advance();
191
+
192
+ rerender({ search: "abc" });
193
+ unmount();
194
+ await advance(bounceTime * 2);
195
+
196
+ expect(searches()).toStrictEqual(["a", "ab"]);
197
+ });
198
+ });
199
+ });