@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
@@ -0,0 +1,507 @@
1
+ import { Socket } from "@hyper-fetch/sockets";
2
+ import { act, render, renderHook, screen } from "@testing-library/react";
3
+ import { useListener } from "hooks/use-listener";
4
+ import React, { StrictMode, useState } from "react";
5
+
6
+ import type { ControlledWebSocket } from "../../../../sockets/__tests__/utils/controlled-websocket";
7
+ import {
8
+ ControlledWebSocket as Transport,
9
+ flushPromises,
10
+ installControlledWebSocket,
11
+ openWebSocket,
12
+ uninstallControlledWebSocket,
13
+ } from "../../../../sockets/__tests__/utils/controlled-websocket";
14
+
15
+ type Message = { text: string };
16
+
17
+ describe("useListener [ Lifecycle ]", () => {
18
+ let socket: Socket;
19
+ let websocket: ControlledWebSocket;
20
+ let listener: ReturnType<typeof createListener>;
21
+ const sockets: Socket[] = [];
22
+
23
+ const createSocket = (url = "ws://use-listener") => {
24
+ const instance = new Socket({ url, reconnectTime: 100 });
25
+ sockets.push(instance);
26
+ return instance;
27
+ };
28
+
29
+ const createListener = (instance: Socket = socket) => {
30
+ return instance.createListener<Message>()({ topic: "chat/:roomId" });
31
+ };
32
+
33
+ /** Number of callbacks the adapter holds for a topic - one per live subscription */
34
+ const subscriptions = (topic: string, instance: Socket = socket) => {
35
+ return instance.adapter.listeners.get(topic)?.size ?? 0;
36
+ };
37
+
38
+ const emit = (topic: string, message: Message, transport: ControlledWebSocket = websocket) => {
39
+ act(() => {
40
+ transport.serverEmit(topic, message);
41
+ });
42
+ };
43
+
44
+ beforeEach(async () => {
45
+ installControlledWebSocket();
46
+ socket = createSocket();
47
+ websocket = await openWebSocket();
48
+ listener = createListener();
49
+ });
50
+
51
+ afterEach(async () => {
52
+ await Promise.all(sockets.map((instance) => instance.disconnect()));
53
+ sockets.length = 0;
54
+ uninstallControlledWebSocket();
55
+ });
56
+
57
+ describe("When the component mounts and unmounts", () => {
58
+ it("should subscribe once on mount", () => {
59
+ const listen = vi.spyOn(socket.adapter, "listen");
60
+
61
+ renderHook(() => useListener(listener.setParams({ roomId: 1 })));
62
+
63
+ expect(listen).toHaveBeenCalledTimes(1);
64
+ expect(subscriptions("chat/1")).toBe(1);
65
+ });
66
+
67
+ it("should unsubscribe on unmount", () => {
68
+ const removed = vi.fn();
69
+ socket.events.onListenerRemove(removed);
70
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 })));
71
+
72
+ view.unmount();
73
+
74
+ expect(subscriptions("chat/1")).toBe(0);
75
+ expect(removed).toHaveBeenCalledTimes(1);
76
+ });
77
+
78
+ it("should leave no socket event subscriptions after unmount", () => {
79
+ const before = socket.emitter.eventNames().length;
80
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 })));
81
+
82
+ view.unmount();
83
+
84
+ expect(socket.emitter.eventNames()).toHaveLength(before);
85
+ });
86
+
87
+ it("should not subscribe again when the component re-renders", () => {
88
+ const listen = vi.spyOn(socket.adapter, "listen");
89
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 })));
90
+
91
+ view.rerender();
92
+ view.rerender();
93
+ view.rerender();
94
+
95
+ expect(listen).toHaveBeenCalledTimes(1);
96
+ expect(subscriptions("chat/1")).toBe(1);
97
+ });
98
+
99
+ it("should not update the state after unmount", () => {
100
+ const renders = vi.fn();
101
+ const view = renderHook(() => {
102
+ renders();
103
+ return useListener(listener.setParams({ roomId: 1 })).data;
104
+ });
105
+ view.unmount();
106
+ renders.mockClear();
107
+ const consoleError = vi.spyOn(console, "error").mockImplementation(() => null);
108
+
109
+ emit("chat/1", { text: "late" });
110
+
111
+ expect(renders).not.toHaveBeenCalled();
112
+ expect(consoleError).not.toHaveBeenCalled();
113
+ consoleError.mockRestore();
114
+ });
115
+
116
+ it("should not receive the messages sent before the mount", () => {
117
+ emit("chat/1", { text: "early" });
118
+
119
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 })));
120
+
121
+ expect(view.result.current.data).toBeNull();
122
+ expect(view.result.current.timestamp).toBeNull();
123
+ });
124
+ });
125
+
126
+ describe("When messages arrive", () => {
127
+ it("should expose the latest message as data with extra and timestamp", () => {
128
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
129
+
130
+ emit("chat/1", { text: "first" });
131
+ emit("chat/1", { text: "second" });
132
+
133
+ expect(view.result.current.data).toStrictEqual({ text: "second" });
134
+ expect(view.result.current.extra).toBeInstanceOf(MessageEvent);
135
+ expect(view.result.current.timestamp).toBeNumber();
136
+ });
137
+
138
+ it("should call onEvent for every message", () => {
139
+ const spy = vi.fn();
140
+ renderHook(() => {
141
+ const { onEvent } = useListener(listener.setParams({ roomId: 1 }));
142
+ onEvent(({ data }) => spy(data));
143
+ });
144
+
145
+ emit("chat/1", { text: "first" });
146
+ emit("chat/1", { text: "second" });
147
+
148
+ expect(spy.mock.calls).toStrictEqual([[{ text: "first" }], [{ text: "second" }]]);
149
+ });
150
+
151
+ it("should call the latest onEvent callback without subscribing again", () => {
152
+ const listen = vi.spyOn(socket.adapter, "listen");
153
+ const calls: string[] = [];
154
+ const view = renderHook(
155
+ ({ label }: { label: string }) => {
156
+ const { onEvent } = useListener(listener.setParams({ roomId: 1 }));
157
+ onEvent(({ data }) => calls.push(`${label}:${data.text}`));
158
+ },
159
+ { initialProps: { label: "first-render" } },
160
+ );
161
+
162
+ emit("chat/1", { text: "a" });
163
+ view.rerender({ label: "second-render" });
164
+ emit("chat/1", { text: "b" });
165
+
166
+ expect(calls).toStrictEqual(["first-render:a", "second-render:b"]);
167
+ expect(listen).toHaveBeenCalledTimes(1);
168
+ });
169
+
170
+ it("should ignore the messages of other topics", () => {
171
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
172
+
173
+ emit("chat/2", { text: "other room" });
174
+
175
+ expect(view.result.current.data).toBeNull();
176
+ });
177
+
178
+ it("should re-render only for the values the component reads", () => {
179
+ const renders = vi.fn();
180
+ renderHook(() => {
181
+ renders();
182
+ return useListener(listener.setParams({ roomId: 1 })).connected;
183
+ });
184
+ renders.mockClear();
185
+
186
+ emit("chat/1", { text: "first" });
187
+ emit("chat/1", { text: "second" });
188
+
189
+ expect(renders).not.toHaveBeenCalled();
190
+ });
191
+ });
192
+
193
+ describe("When the listener changes", () => {
194
+ it("should move the subscription to the new topic exactly once", () => {
195
+ const listen = vi.spyOn(socket.adapter, "listen");
196
+ const view = renderHook(
197
+ ({ roomId }: { roomId: number }) => useListener(listener.setParams({ roomId }), { dependencyTracking: false }),
198
+ { initialProps: { roomId: 1 } },
199
+ );
200
+
201
+ view.rerender({ roomId: 2 });
202
+
203
+ expect(listen).toHaveBeenCalledTimes(2);
204
+ expect(subscriptions("chat/1")).toBe(0);
205
+ expect(subscriptions("chat/2")).toBe(1);
206
+ });
207
+
208
+ it("should receive only the messages of the new topic", () => {
209
+ const view = renderHook(
210
+ ({ roomId }: { roomId: number }) => useListener(listener.setParams({ roomId }), { dependencyTracking: false }),
211
+ { initialProps: { roomId: 1 } },
212
+ );
213
+ view.rerender({ roomId: 2 });
214
+
215
+ emit("chat/1", { text: "old room" });
216
+ expect(view.result.current.data).toBeNull();
217
+
218
+ emit("chat/2", { text: "new room" });
219
+ expect(view.result.current.data).toStrictEqual({ text: "new room" });
220
+ });
221
+
222
+ it("should keep the subscription when an equal listener is created on every render", () => {
223
+ const listen = vi.spyOn(socket.adapter, "listen");
224
+ const view = renderHook(() => useListener(createListener().setParams({ roomId: 1 })));
225
+
226
+ view.rerender();
227
+ view.rerender();
228
+
229
+ expect(listen).toHaveBeenCalledTimes(1);
230
+ expect(subscriptions("chat/1")).toBe(1);
231
+ });
232
+
233
+ it("should follow a listener of another socket with the same topic", async () => {
234
+ const otherSocket = createSocket("ws://other-socket");
235
+ const otherWebsocket = await openWebSocket(2);
236
+ const otherListener = createListener(otherSocket);
237
+ const view = renderHook(
238
+ ({ current }: { current: typeof listener }) =>
239
+ useListener(current.setParams({ roomId: 1 }), { dependencyTracking: false }),
240
+ { initialProps: { current: listener } },
241
+ );
242
+
243
+ view.rerender({ current: otherListener });
244
+
245
+ expect(subscriptions("chat/1", socket)).toBe(0);
246
+ expect(subscriptions("chat/1", otherSocket)).toBe(1);
247
+
248
+ emit("chat/1", { text: "old socket" });
249
+ expect(view.result.current.data).toBeNull();
250
+
251
+ emit("chat/1", { text: "new socket" }, otherWebsocket);
252
+ expect(view.result.current.data).toStrictEqual({ text: "new socket" });
253
+ });
254
+
255
+ it("should subscribe again when listen is called manually", () => {
256
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
257
+
258
+ act(() => {
259
+ view.result.current.listen();
260
+ view.result.current.listen();
261
+ });
262
+ emit("chat/1", { text: "hello" });
263
+
264
+ expect(subscriptions("chat/1")).toBe(1);
265
+ expect(view.result.current.data).toStrictEqual({ text: "hello" });
266
+ });
267
+ });
268
+
269
+ describe("When rendered in StrictMode", () => {
270
+ const wrapper = ({ children }: { children: React.ReactNode }) => <StrictMode>{children}</StrictMode>;
271
+
272
+ it("should hold a single subscription", () => {
273
+ renderHook(() => useListener(listener.setParams({ roomId: 1 })), { wrapper });
274
+
275
+ expect(subscriptions("chat/1")).toBe(1);
276
+ });
277
+
278
+ it("should call onEvent once per message", () => {
279
+ const spy = vi.fn();
280
+ renderHook(
281
+ () => {
282
+ const { onEvent } = useListener(listener.setParams({ roomId: 1 }));
283
+ onEvent(({ data }) => spy(data));
284
+ },
285
+ { wrapper },
286
+ );
287
+
288
+ emit("chat/1", { text: "once" });
289
+
290
+ expect(spy).toHaveBeenCalledTimes(1);
291
+ });
292
+
293
+ it("should report the connection state of the socket", () => {
294
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }), {
295
+ wrapper,
296
+ });
297
+
298
+ expect(view.result.current.connected).toBeTrue();
299
+
300
+ act(() => {
301
+ websocket.serverClose({ code: 1000, wasClean: true });
302
+ });
303
+
304
+ expect(view.result.current.connected).toBeFalse();
305
+ });
306
+
307
+ it("should leave no subscription after unmount", () => {
308
+ const before = socket.emitter.eventNames().length;
309
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 })), { wrapper });
310
+
311
+ view.unmount();
312
+
313
+ expect(subscriptions("chat/1")).toBe(0);
314
+ expect(socket.emitter.eventNames()).toHaveLength(before);
315
+ });
316
+ });
317
+
318
+ describe("When many components share a socket", () => {
319
+ const Room = ({ roomId }: { roomId: number }) => {
320
+ const { data } = useListener(listener.setParams({ roomId }));
321
+ return <span data-testid={`room-${roomId}`}>{data?.text ?? "empty"}</span>;
322
+ };
323
+
324
+ const SameRoom = ({ id }: { id: string }) => {
325
+ const { data } = useListener(listener.setParams({ roomId: 1 }));
326
+ return <span data-testid={id}>{data?.text ?? "empty"}</span>;
327
+ };
328
+
329
+ it("should deliver a message to every component listening to the topic", () => {
330
+ render(
331
+ <>
332
+ <SameRoom id="first" />
333
+ <SameRoom id="second" />
334
+ </>,
335
+ );
336
+
337
+ emit("chat/1", { text: "hello" });
338
+
339
+ expect(screen.getByTestId("first")).toHaveTextContent("hello");
340
+ expect(screen.getByTestId("second")).toHaveTextContent("hello");
341
+ expect(subscriptions("chat/1")).toBe(2);
342
+ });
343
+
344
+ it("should route the messages by topic between components", () => {
345
+ render(
346
+ <>
347
+ <Room roomId={1} />
348
+ <Room roomId={2} />
349
+ </>,
350
+ );
351
+
352
+ emit("chat/2", { text: "second room" });
353
+
354
+ expect(screen.getByTestId("room-1")).toHaveTextContent("empty");
355
+ expect(screen.getByTestId("room-2")).toHaveTextContent("second room");
356
+ });
357
+
358
+ it("should keep the other components subscribed when one unmounts", () => {
359
+ const App = () => {
360
+ const [visible, setVisible] = useState(true);
361
+ return (
362
+ <>
363
+ {visible && <SameRoom id="first" />}
364
+ <SameRoom id="second" />
365
+ <button type="button" onClick={() => setVisible(false)}>
366
+ hide
367
+ </button>
368
+ </>
369
+ );
370
+ };
371
+ render(<App />);
372
+
373
+ act(() => {
374
+ screen.getByText("hide").click();
375
+ });
376
+ emit("chat/1", { text: "still here" });
377
+
378
+ expect(screen.queryByTestId("first")).toBeNull();
379
+ expect(screen.getByTestId("second")).toHaveTextContent("still here");
380
+ expect(subscriptions("chat/1")).toBe(1);
381
+ });
382
+ });
383
+
384
+ describe("When the connection state changes", () => {
385
+ it("should start with the current state of the socket", async () => {
386
+ const idle = new Socket({ url: "ws://idle", adapterOptions: { autoConnect: false } });
387
+ const idleListener = idle.createListener<Message>()({ topic: "chat" });
388
+
389
+ const connected = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
390
+ const disconnected = renderHook(() => useListener(idleListener, { dependencyTracking: false }));
391
+
392
+ expect(connected.result.current.connected).toBeTrue();
393
+ expect(connected.result.current.connecting).toBeFalse();
394
+ expect(disconnected.result.current.connected).toBeFalse();
395
+ expect(disconnected.result.current.connecting).toBeFalse();
396
+ });
397
+
398
+ it("should follow connecting, connected and disconnected", async () => {
399
+ const lazy = createSocket("ws://lazy");
400
+ await flushPromises();
401
+ const lazyListener = lazy.createListener<Message>()({ topic: "chat" });
402
+ const view = renderHook(() => useListener(lazyListener, { dependencyTracking: false }));
403
+
404
+ expect(view.result.current.connecting).toBeTrue();
405
+ expect(view.result.current.connected).toBeFalse();
406
+
407
+ act(() => {
408
+ Transport.last.serverOpen();
409
+ });
410
+ expect(view.result.current.connecting).toBeFalse();
411
+ expect(view.result.current.connected).toBeTrue();
412
+
413
+ await act(async () => {
414
+ await lazy.disconnect();
415
+ });
416
+ expect(view.result.current.connected).toBeFalse();
417
+ });
418
+
419
+ it("should become connected again after a reconnect", async () => {
420
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
421
+
422
+ let reconnecting: Promise<void> = Promise.resolve();
423
+ await act(async () => {
424
+ reconnecting = socket.reconnect();
425
+ await flushPromises();
426
+ });
427
+ expect(view.result.current.connected).toBeFalse();
428
+ expect(view.result.current.connecting).toBeTrue();
429
+
430
+ await act(async () => {
431
+ Transport.last.serverOpen();
432
+ await reconnecting;
433
+ });
434
+ expect(view.result.current.connected).toBeTrue();
435
+ expect(view.result.current.connecting).toBeFalse();
436
+ expect(subscriptions("chat/1")).toBe(1);
437
+ });
438
+
439
+ it("should keep receiving messages after a reconnect", async () => {
440
+ const view = renderHook(() => useListener(listener.setParams({ roomId: 1 }), { dependencyTracking: false }));
441
+
442
+ await act(async () => {
443
+ const reconnecting = socket.reconnect();
444
+ const next = await openWebSocket(2);
445
+ await reconnecting;
446
+ next.serverEmit("chat/1", { text: "after reconnect" });
447
+ });
448
+
449
+ expect(view.result.current.data).toStrictEqual({ text: "after reconnect" });
450
+ });
451
+
452
+ it("should call the latest connection callbacks", async () => {
453
+ const calls: string[] = [];
454
+ renderHook(() => {
455
+ const { onConnected, onDisconnected, onConnecting, onReconnecting, onReconnectingFailed, onError } =
456
+ useListener(listener.setParams({ roomId: 1 }));
457
+ onConnected(() => calls.push("connected"));
458
+ onDisconnected(() => calls.push("disconnected"));
459
+ onConnecting(() => calls.push("connecting"));
460
+ onReconnecting(({ attempts }) => calls.push(`reconnecting:${attempts}`));
461
+ onReconnectingFailed(({ attempts }) => calls.push(`failed:${attempts}`));
462
+ onError(() => calls.push("error"));
463
+ });
464
+
465
+ await act(async () => {
466
+ const reconnecting = socket.reconnect();
467
+ await openWebSocket(2);
468
+ await reconnecting;
469
+ });
470
+ act(() => {
471
+ socket.events.emitReconnectingFailed({ attempts: 3 });
472
+ socket.events.emitError({ error: new Error("Lost") });
473
+ });
474
+
475
+ expect(calls).toStrictEqual([
476
+ "reconnecting:0",
477
+ "connecting",
478
+ "disconnected",
479
+ "connecting",
480
+ "connecting",
481
+ "connected",
482
+ "failed:3",
483
+ "error",
484
+ ]);
485
+ });
486
+
487
+ it("should catch up when the socket connected between the render and the effect", async () => {
488
+ const lazy = createSocket("ws://lazy");
489
+ const lazyWebsocket = await Promise.resolve()
490
+ .then(() => flushPromises())
491
+ .then(() => Transport.last);
492
+ const lazyListener = lazy.createListener<Message>()({ topic: "chat" });
493
+ const Component = () => {
494
+ // The connection opens while the component renders, before its effects subscribe to the socket
495
+ if (lazyWebsocket.readyState === Transport.CONNECTING) {
496
+ lazyWebsocket.serverOpen();
497
+ }
498
+ const { connected } = useListener(lazyListener);
499
+ return <span data-testid="state">{String(connected)}</span>;
500
+ };
501
+
502
+ render(<Component />);
503
+
504
+ expect(screen.getByTestId("state")).toHaveTextContent("true");
505
+ });
506
+ });
507
+ });
@@ -0,0 +1,89 @@
1
+ // @vitest-environment node
2
+ import { Socket } from "@hyper-fetch/sockets";
3
+ import { useEmitter } from "hooks/use-emitter";
4
+ import { useListener } from "hooks/use-listener";
5
+ import React from "react";
6
+ import { renderToString } from "react-dom/server";
7
+
8
+ type Message = { text: string };
9
+
10
+ describe("useListener & useEmitter [ SSR ]", () => {
11
+ let socket: Socket;
12
+
13
+ beforeEach(() => {
14
+ socket = new Socket({ url: "ws://ssr" });
15
+ socket.onError(() => null);
16
+ });
17
+
18
+ afterEach(async () => {
19
+ await socket.disconnect();
20
+ });
21
+
22
+ it("should run without window", () => {
23
+ expect(typeof window).toBe("undefined");
24
+ });
25
+
26
+ it("should render useListener on the server with the empty state", () => {
27
+ const listener = socket.createListener<Message>()({ topic: "chat" });
28
+ const Component = () => {
29
+ const { data, connected, connecting, timestamp } = useListener(listener);
30
+ return (
31
+ <p>
32
+ {String(data)}|{String(connected)}|{String(connecting)}|{String(timestamp)}
33
+ </p>
34
+ );
35
+ };
36
+
37
+ const html = renderToString(<Component />);
38
+
39
+ expect(html.replaceAll("<!-- -->", "")).toBe("<p>null|false|false|null</p>");
40
+ });
41
+
42
+ it("should not subscribe to the socket during the server render", () => {
43
+ const listener = socket.createListener<Message>()({ topic: "chat" });
44
+ const listen = vi.spyOn(socket.adapter, "listen");
45
+ const before = socket.emitter.eventNames().length;
46
+ const Component = () => {
47
+ const { onEvent, onConnected } = useListener(listener);
48
+ onEvent(() => null);
49
+ onConnected(() => null);
50
+ return null;
51
+ };
52
+
53
+ renderToString(<Component />);
54
+
55
+ expect(listen).not.toHaveBeenCalled();
56
+ expect(socket.adapter.listeners.size).toBe(0);
57
+ expect(socket.emitter.eventNames()).toHaveLength(before);
58
+ });
59
+
60
+ it("should render useEmitter on the server with the empty state", () => {
61
+ const emitter = socket.createEmitter<Message>()({ topic: "chat" });
62
+ const before = socket.emitter.eventNames().length;
63
+ const Component = () => {
64
+ const { connected, connecting, onEmit, onEmitError } = useEmitter(emitter);
65
+ onEmit(() => null);
66
+ onEmitError(() => null);
67
+ return (
68
+ <p>
69
+ {String(connected)}|{String(connecting)}
70
+ </p>
71
+ );
72
+ };
73
+
74
+ const html = renderToString(<Component />);
75
+
76
+ expect(html.replaceAll("<!-- -->", "")).toBe("<p>false|false</p>");
77
+ expect(socket.emitter.eventNames()).toHaveLength(before);
78
+ });
79
+
80
+ it("should render the same output for every server render", () => {
81
+ const listener = socket.createListener<Message>()({ topic: "chat" });
82
+ const Component = () => {
83
+ const { data, connected } = useListener(listener, { dependencyTracking: false });
84
+ return <p>{JSON.stringify({ data, connected })}</p>;
85
+ };
86
+
87
+ expect(renderToString(<Component />)).toBe(renderToString(<Component />));
88
+ });
89
+ });