@hyper-fetch/sockets 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 (39) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +27 -6
  3. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  4. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  5. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  6. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  7. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  8. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  9. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  10. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  11. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  12. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  13. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  14. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  15. package/__tests__/utils/controlled-event-source.ts +149 -0
  16. package/__tests__/utils/controlled-websocket.ts +213 -0
  17. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  18. package/dist/adapter/adapter.d.ts.map +1 -1
  19. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  20. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  21. package/dist/emitter/emitter.d.ts.map +1 -1
  22. package/dist/index.mjs +284 -105
  23. package/dist/index.mjs.map +1 -1
  24. package/dist/listener/listener.d.ts +2 -0
  25. package/dist/listener/listener.d.ts.map +1 -1
  26. package/dist/socket/socket.d.ts +1 -1
  27. package/dist/socket/socket.utils.d.ts +11 -3
  28. package/dist/socket/socket.utils.d.ts.map +1 -1
  29. package/dist/utils/topic.utils.d.ts +10 -0
  30. package/dist/utils/topic.utils.d.ts.map +1 -0
  31. package/package.json +1 -1
  32. package/src/adapter/adapter.bindings.ts +44 -20
  33. package/src/adapter/adapter.ts +29 -10
  34. package/src/adapter-sse/sse-adapter.ts +95 -15
  35. package/src/adapter-websockets/websocket-adapter.ts +124 -41
  36. package/src/emitter/emitter.ts +16 -9
  37. package/src/listener/listener.ts +7 -8
  38. package/src/socket/socket.utils.ts +20 -6
  39. package/src/utils/topic.utils.ts +26 -0
package/dist/index.mjs CHANGED
@@ -82,7 +82,6 @@ var getAdapterBindings = (socket) => {
82
82
  const currentConnectionId = connectionId;
83
83
  socket.adapter.setForceClosed(false);
84
84
  socket.adapter.setConnecting(true);
85
- socket.adapter.setReconnectionAttempts(0);
86
85
  socket.events.emitConnecting({ connecting: true });
87
86
  const defaults = {
88
87
  url: socket.url,
@@ -138,7 +137,6 @@ var getAdapterBindings = (socket) => {
138
137
  extra: { reconnectionAttempts: nextAttempts }
139
138
  });
140
139
  await connect();
141
- if (!adapter.connected) socket.adapter.setReconnectionAttempts(nextAttempts);
142
140
  return true;
143
141
  }
144
142
  logger.error({
@@ -159,25 +157,50 @@ var getAdapterBindings = (socket) => {
159
157
  callback
160
158
  });
161
159
  };
160
+ const onEmitError = ({ emitter, error }) => {
161
+ socket.events.emitEmitterError({
162
+ error,
163
+ emitter
164
+ });
165
+ };
166
+ /**
167
+ * Prepares an emitter for sending - maps the payload and runs the `onSend` interceptors.
168
+ * Returns `null` when the message cannot be sent; the reason is reported with the emitter error event
169
+ * (and to the `onError` callbacks when the payload mapper or an interceptor failed), it never rejects.
170
+ */
162
171
  const onEmit = async ({ emitter }) => {
163
172
  if (adapter.connecting || !adapter.connected) {
173
+ const error = /* @__PURE__ */ new Error("Cannot emit event when connection is not open");
164
174
  logger.error({
165
- title: "Cannot emit event when connection is not open",
175
+ title: error.message,
166
176
  type: "system",
167
177
  extra: {}
168
178
  });
179
+ onEmitError({
180
+ emitter,
181
+ error
182
+ });
183
+ return null;
184
+ }
185
+ try {
186
+ emitter.payload = emitter.unstable_payloadMapper ? await emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
187
+ const emitterInstance = await socket.unstable__modifySend(emitter);
188
+ socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
189
+ return emitterInstance;
190
+ } catch (error) {
191
+ const emitError = error instanceof Error ? error : new Error(String(error));
192
+ logger.error({
193
+ title: "Cannot prepare event to emit",
194
+ type: "system",
195
+ extra: { error: emitError }
196
+ });
197
+ onEmitError({
198
+ emitter,
199
+ error: emitError
200
+ });
201
+ onError({ error: emitError });
169
202
  return null;
170
203
  }
171
- emitter.payload = emitter.unstable_payloadMapper ? emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
172
- const emitterInstance = await socket.unstable__modifySend(emitter);
173
- socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
174
- return emitterInstance;
175
- };
176
- const onEmitError = ({ emitter, error }) => {
177
- socket.events.emitEmitterError({
178
- error,
179
- emitter
180
- });
181
204
  };
182
205
  const onConnected = () => {
183
206
  logger.info({
@@ -218,20 +241,29 @@ var getAdapterBindings = (socket) => {
218
241
  extra
219
242
  }
220
243
  });
221
- const { data: modifiedData, extra: modifiedExtra } = socket.unstable__modifyResponse({
222
- data,
223
- extra
224
- });
225
- socket.adapter.triggerListeners({
226
- topic,
227
- data: modifiedData,
228
- extra: modifiedExtra
229
- });
230
- socket.events.emitListenerEvent({
231
- topic,
232
- data: modifiedData,
233
- extra: modifiedExtra
234
- });
244
+ let message;
245
+ try {
246
+ message = socket.unstable__modifyResponse({
247
+ data,
248
+ extra
249
+ });
250
+ } catch (error) {
251
+ onError({ error: error instanceof Error ? error : new Error(String(error)) });
252
+ return;
253
+ }
254
+ try {
255
+ socket.adapter.triggerListeners({
256
+ topic,
257
+ data: message.data,
258
+ extra: message.extra
259
+ });
260
+ } finally {
261
+ socket.events.emitListenerEvent({
262
+ topic,
263
+ data: message.data,
264
+ extra: message.extra
265
+ });
266
+ }
235
267
  };
236
268
  /** Maps query params to the format required by the adapter (defaults to the adapter's stored query params) */
237
269
  const getQueryParams = (queryParams = adapter.queryParams) => socket.adapter.unstable_queryParamsMapper(queryParams, socket.adapter.queryParamsConfig);
@@ -339,23 +371,30 @@ var SocketAdapter = class {
339
371
  };
340
372
  removeListener = ({ topic, callback }) => {
341
373
  const listenerGroup = this.listeners.get(topic);
342
- if (listenerGroup) {
343
- const unmount = listenerGroup.get(callback);
344
- this.socket.events.emitListenerRemoveEvent({ topic });
345
- listenerGroup.delete(callback);
346
- unmount?.();
347
- return true;
348
- }
349
- return false;
374
+ if (!listenerGroup?.has(callback)) return false;
375
+ const unmount = listenerGroup.get(callback);
376
+ listenerGroup.delete(callback);
377
+ this.socket.events.emitListenerRemoveEvent({ topic });
378
+ unmount?.();
379
+ return true;
350
380
  };
351
381
  triggerListeners = ({ topic, data, extra }) => {
352
382
  const listenerGroup = this.listeners.get(topic);
353
- if (listenerGroup) listenerGroup.forEach((_, action) => {
354
- action({
355
- data,
356
- extra
357
- });
383
+ if (!listenerGroup?.size) return;
384
+ const callbacks = [...listenerGroup.keys()];
385
+ const errors = [];
386
+ callbacks.forEach((action) => {
387
+ if (!listenerGroup.has(action)) return;
388
+ try {
389
+ action({
390
+ data,
391
+ extra
392
+ });
393
+ } catch (error) {
394
+ errors.push(error);
395
+ }
358
396
  });
397
+ if (errors.length > 0) throw errors[0];
359
398
  };
360
399
  setConnected = (connected) => {
361
400
  this.connected = connected;
@@ -453,14 +492,21 @@ var getWebsocketAdapter = (url, adapterOptions) => {
453
492
  //#endregion
454
493
  //#region src/adapter-websockets/websocket-adapter.ts
455
494
  /** Create a preconfigured socket adapter for native WebSocket connections. */
456
- var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onEmit, onConnected, onDisconnected, onError, onEvent }) => {
495
+ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onEmit, onEmitError, onConnected, onDisconnected, onError, onEvent }) => {
457
496
  const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
458
497
  let websocket;
459
498
  let options = socket.adapter.adapterOptions;
499
+ let pendingConnection;
460
500
  let pingTimer;
461
501
  let pongTimer;
462
502
  let timeout;
463
- const connect = async () => {
503
+ const scheduleReconnect = () => {
504
+ clearTimeout(timeout);
505
+ timeout = setTimeout(() => {
506
+ reconnect();
507
+ }, socket.reconnectTime);
508
+ };
509
+ const openConnection = async () => {
464
510
  const connection = await onConnect();
465
511
  if (!connection) return socket.adapter.connected;
466
512
  clearTimeout(timeout);
@@ -468,31 +514,30 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
468
514
  websocket?.close(1e3);
469
515
  options = connection.adapterOptions;
470
516
  const newWebsocket = createWebsocket(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), options);
471
- websocket = newWebsocket;
517
+ websocket = newWebsocket ?? void 0;
472
518
  if (!newWebsocket) return false;
473
- newWebsocket.clearListeners();
474
- timeout = setTimeout(() => {
475
- reconnect();
476
- }, socket.reconnectTime);
519
+ const isCurrent = () => websocket === newWebsocket;
520
+ scheduleReconnect();
477
521
  /**
478
522
  * Mount listeners
479
523
  */
480
524
  newWebsocket.addEventListener("open", () => {
525
+ if (!isCurrent()) return;
481
526
  clearTimeout(timeout);
482
527
  onConnected();
483
528
  onHeartbeat();
484
529
  });
485
530
  newWebsocket.addEventListener("close", (event) => {
531
+ if (!isCurrent()) return;
486
532
  clearTimeout(timeout);
487
- onDisconnected();
488
533
  clearTimers();
534
+ onDisconnected();
489
535
  const error = getSocketError(event);
490
536
  onError({ error: new Error(error) });
491
- if (event.code !== 1e3) timeout = setTimeout(() => {
492
- reconnect();
493
- }, socket.reconnectTime);
537
+ if (event.code !== 1e3) scheduleReconnect();
494
538
  });
495
539
  newWebsocket.addEventListener("message", (newEvent) => {
540
+ if (!isCurrent()) return;
496
541
  onHeartbeat();
497
542
  const message = decodeMessage(newEvent);
498
543
  if (message) onEvent({
@@ -526,31 +571,55 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
526
571
  newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
527
572
  });
528
573
  };
529
- const disconnect = async () => {
574
+ const connect = () => {
575
+ if (socket.adapter.connecting && pendingConnection) return pendingConnection;
576
+ const connection = openConnection();
577
+ pendingConnection = connection;
578
+ const release = () => {
579
+ if (pendingConnection === connection) pendingConnection = void 0;
580
+ };
581
+ connection.then(release, release);
582
+ return connection;
583
+ };
584
+ /**
585
+ * Closes the transport and resets the connection state. From this point the closed transport is detached -
586
+ * whatever it reports later (close code, errors, late frames) does not reach the socket anymore,
587
+ * so closing on purpose is never treated as a lost connection.
588
+ */
589
+ const closeConnection = async ({ manual }) => {
530
590
  clearTimeout(timeout);
591
+ clearTimers();
531
592
  const currentWebsocket = websocket;
532
- if (!(currentWebsocket && currentWebsocket.readyState !== WebSocket.CLOSED)) {
533
- const wasConnecting = socket.adapter.connecting;
534
- onDisconnect();
535
- if (wasConnecting) onDisconnected();
536
- return true;
537
- }
538
- const promise = new Promise((resolve) => {
593
+ websocket = void 0;
594
+ const wasActive = socket.adapter.connected || socket.adapter.connecting;
595
+ onDisconnect();
596
+ if (!manual) socket.adapter.setForceClosed(false);
597
+ if (wasActive) onDisconnected();
598
+ if (!currentWebsocket || currentWebsocket.readyState === WebSocket.CLOSED) return true;
599
+ return new Promise((resolve) => {
539
600
  const resolveDisconnected = () => {
540
601
  resolve(true);
541
602
  currentWebsocket.removeEventListener("close", resolveDisconnected);
542
603
  };
543
604
  currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
605
+ currentWebsocket.close(1e3);
544
606
  });
545
- onDisconnect();
546
- currentWebsocket.close(1e3);
547
- clearTimers();
548
- return promise;
607
+ };
608
+ /** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
609
+ const disconnect = () => {
610
+ return closeConnection({ manual: true });
549
611
  };
550
612
  const reconnect = async () => {
613
+ socket.adapter.setForceClosed(false);
551
614
  await onReconnect({
552
- disconnect,
553
- connect
615
+ disconnect: () => closeConnection({ manual: false }),
616
+ connect: async () => {
617
+ if (socket.adapter.forceClosed) {
618
+ socket.adapter.setReconnectionAttempts(0);
619
+ return false;
620
+ }
621
+ return connect();
622
+ }
554
623
  });
555
624
  };
556
625
  /** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
@@ -582,8 +651,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
582
651
  return null;
583
652
  }
584
653
  };
654
+ /** Encodes and sends a message. Returns the error instead of throwing, so callers decide how to report it. */
585
655
  const sendEventMessage = ({ topic, payload }) => {
586
- if (!websocket) return false;
656
+ if (!websocket) return /* @__PURE__ */ new Error("Cannot send event when connection is not open");
587
657
  try {
588
658
  const frame = options?.encode ? options.encode({
589
659
  topic,
@@ -593,10 +663,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
593
663
  data: payload
594
664
  });
595
665
  websocket.send(frame);
596
- return true;
666
+ return null;
597
667
  } catch (error) {
598
- onError({ error });
599
- return false;
668
+ return error instanceof Error ? error : new Error(String(error));
600
669
  }
601
670
  };
602
671
  const onHeartbeat = () => {
@@ -606,15 +675,31 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
606
675
  if (socket.adapter.connecting || !heartbeat) return;
607
676
  clearTimers();
608
677
  pingTimer = setTimeout(() => {
609
- sendEventMessage({
678
+ const error = sendEventMessage({
610
679
  topic: "heartbeat",
611
680
  payload: heartbeatMessage
612
681
  });
682
+ if (error) onError({ error });
613
683
  pongTimer = setTimeout(() => {
614
- websocket?.close();
684
+ onHeartbeatTimeout();
615
685
  }, pongTimeout);
616
686
  }, pingTimeout);
617
687
  };
688
+ /**
689
+ * The server did not answer the ping - the connection is dead. On a dead connection the closing handshake
690
+ * may take very long (or never finish), so the socket is marked as disconnected right away instead of
691
+ * waiting for the `close` event of the transport.
692
+ */
693
+ const onHeartbeatTimeout = () => {
694
+ const deadWebsocket = websocket;
695
+ if (!deadWebsocket) return;
696
+ websocket = void 0;
697
+ clearTimers();
698
+ deadWebsocket.close();
699
+ onDisconnected();
700
+ onError({ error: /* @__PURE__ */ new Error("Heartbeat timeout - the server did not respond to the ping in time") });
701
+ scheduleReconnect();
702
+ };
618
703
  const listen = (listener, callback) => {
619
704
  return onListen({
620
705
  listener,
@@ -624,11 +709,20 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
624
709
  const emit = async (emitter) => {
625
710
  const mappedEmitter = await onEmit({ emitter });
626
711
  if (!mappedEmitter) return;
627
- return sendEventMessage(mappedEmitter);
712
+ const error = sendEventMessage(mappedEmitter);
713
+ if (error) {
714
+ onEmitError({
715
+ emitter: mappedEmitter,
716
+ error
717
+ });
718
+ onError({ error });
719
+ return false;
720
+ }
721
+ return true;
628
722
  };
629
723
  if (autoConnect) connect();
630
724
  socket.appManager.events.onOnline(() => {
631
- if (autoConnect && !socket.adapter.connected) connect();
725
+ if (autoConnect && !socket.adapter.connected && !socket.adapter.forceClosed) connect();
632
726
  });
633
727
  return {
634
728
  connect,
@@ -639,6 +733,24 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
639
733
  };
640
734
  });
641
735
  //#endregion
736
+ //#region src/utils/topic.utils.ts
737
+ /**
738
+ * Fills the `:param` segments of a topic template, e.g. `chat/:roomId` + `{ roomId: 1 }` gives `chat/1`.
739
+ *
740
+ * Every `:` segment is replaced once, with the longest matching name. This way `:id` does not eat the beginning
741
+ * of `:idx`, and a value is never parsed again - neither as another param nor as a replacement pattern like `$&`.
742
+ * Segments without a matching param are left untouched.
743
+ */
744
+ var mapTopicParams = (topic, params) => {
745
+ const names = params ? Object.keys(params) : [];
746
+ if (!params || names.length === 0) return topic;
747
+ const [start, ...segments] = topic.split(":");
748
+ return [start, ...segments.map((segment) => {
749
+ const name = names.reduce((longest, current) => segment.startsWith(current) && current.length > longest.length ? current : longest, "");
750
+ return name ? `${params[name]}${segment.slice(name.length)}` : `:${segment}`;
751
+ })].join("");
752
+ };
753
+ //#endregion
642
754
  //#region src/emitter/emitter.ts
643
755
  /**
644
756
  * Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
@@ -679,11 +791,7 @@ var Emitter = class Emitter {
679
791
  return this.clone({ params });
680
792
  }
681
793
  paramsMapper = (params) => {
682
- let topic = this.emitterOptions.topic;
683
- if (params) Object.entries(params).forEach(([key, value]) => {
684
- topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
685
- });
686
- return topic;
794
+ return mapTopicParams(this.emitterOptions.topic, params);
687
795
  };
688
796
  /** Create a new emitter instance with optional configuration overrides. */
689
797
  clone(config) {
@@ -702,7 +810,18 @@ var Emitter = class Emitter {
702
810
  emit = (options = {}) => {
703
811
  const typedOptions = options;
704
812
  const instance = this.clone(typedOptions);
705
- this.socket.adapter.emit(instance);
813
+ const result = this.socket.adapter.emit(instance);
814
+ if (result instanceof Promise) result.catch((error) => {
815
+ const emitError = error instanceof Error ? error : new Error(String(error));
816
+ this.socket.events.emitEmitterError({
817
+ error: emitError,
818
+ emitter: instance
819
+ });
820
+ this.socket.unstable_onErrorCallbacks.forEach((callback) => {
821
+ callback({ error: emitError });
822
+ });
823
+ this.socket.events.emitError({ error: emitError });
824
+ });
706
825
  };
707
826
  };
708
827
  //#endregion
@@ -1186,11 +1305,14 @@ var Listener = class Listener {
1186
1305
  delivery = void 0;
1187
1306
  /** Stored with an `any` response for the same covariance reason as `delivery`. */
1188
1307
  listenerOptions;
1308
+ /** Topic as it was declared (e.g. `chat/:roomId`) - clones keep it, so params can be set again */
1309
+ topicTemplate;
1189
1310
  constructor(socket, listenerOptions) {
1190
1311
  this.socket = socket;
1191
1312
  this.listenerOptions = listenerOptions;
1192
1313
  const { topic, options, delivery, params } = listenerOptions;
1193
1314
  this.topic = topic;
1315
+ this.topicTemplate = topic;
1194
1316
  this.options = options;
1195
1317
  this.params = params;
1196
1318
  this.delivery = delivery;
@@ -1213,11 +1335,13 @@ var Listener = class Listener {
1213
1335
  }
1214
1336
  /** Create a new listener instance with optional configuration overrides. */
1215
1337
  clone(options) {
1216
- return new Listener(this.socket, {
1338
+ const newInstance = new Listener(this.socket, {
1217
1339
  ...this.listenerOptions,
1218
1340
  ...options,
1219
1341
  topic: this.paramsMapper(options?.params || this.params)
1220
1342
  });
1343
+ newInstance.topicTemplate = this.topicTemplate;
1344
+ return newInstance;
1221
1345
  }
1222
1346
  /** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
1223
1347
  listen = (callback) => {
@@ -1234,11 +1358,7 @@ var Listener = class Listener {
1234
1358
  return removeListener;
1235
1359
  };
1236
1360
  paramsMapper = (params) => {
1237
- let topic = this.listenerOptions.topic;
1238
- if (params) Object.entries(params).forEach(([key, value]) => {
1239
- topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
1240
- });
1241
- return topic;
1361
+ return mapTopicParams(this.topicTemplate, params);
1242
1362
  };
1243
1363
  };
1244
1364
  //#endregion
@@ -1473,18 +1593,30 @@ var getListenerRemoveByTopicKey = (event) => `${event}_listener_remove`;
1473
1593
  var getListenerEventByTopicKey = (event) => `${event}_listener_event`;
1474
1594
  var getEmitterStartEventByTopicKey = (event) => `${event}_emitter_start_event`;
1475
1595
  var getEmitterErrorByTopicKey = (event) => `${event}_emitter_error`;
1596
+ /**
1597
+ * Runs the `onMessage` interceptors over the data of an incoming message. Every interceptor receives the data
1598
+ * returned by the previous one - the adapter `extra` is never touched.
1599
+ */
1476
1600
  var interceptListener = (interceptors, event) => {
1477
- let newResponse = event;
1601
+ let { data } = event;
1478
1602
  for (const interceptor of interceptors) {
1479
- newResponse = interceptor({ event: event.data });
1480
- if (!newResponse) throw new Error("Listener modifier must return data");
1603
+ const newData = interceptor({ event: data });
1604
+ if ((newData === void 0 || newData === null && data !== null) && data !== void 0) throw new Error("Listener modifier must return data");
1605
+ data = newData;
1481
1606
  }
1482
- return newResponse;
1607
+ return {
1608
+ data,
1609
+ extra: event.extra
1610
+ };
1483
1611
  };
1612
+ /**
1613
+ * Runs the `onSend` interceptors over an emitter. Every interceptor receives the emitter
1614
+ * returned by the previous one.
1615
+ */
1484
1616
  var interceptEmitter = (interceptors, emitter) => {
1485
1617
  let newEmitter = emitter;
1486
1618
  for (const interceptor of interceptors) {
1487
- newEmitter = interceptor({ emitter });
1619
+ newEmitter = interceptor({ emitter: newEmitter });
1488
1620
  if (!newEmitter) throw new Error("Send modifier must return emitter");
1489
1621
  }
1490
1622
  return newEmitter;
@@ -1663,6 +1795,7 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
1663
1795
  /** Create a preconfigured socket adapter for Server-Sent Events (EventSource) connections. */
1664
1796
  var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, adapter, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onConnected, onDisconnected, onError, onEvent }) => {
1665
1797
  let sse;
1798
+ let pendingConnection;
1666
1799
  let timeout;
1667
1800
  const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
1668
1801
  /** Maps an incoming message to the listener event, reporting decoder failures instead of throwing */
@@ -1679,31 +1812,47 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1679
1812
  return null;
1680
1813
  }
1681
1814
  };
1682
- const connect = async () => {
1815
+ const scheduleReconnect = () => {
1816
+ clearTimeout(timeout);
1817
+ timeout = setTimeout(() => {
1818
+ reconnect();
1819
+ }, socket.reconnectTime);
1820
+ };
1821
+ const openConnection = async () => {
1683
1822
  const connection = await onConnect();
1684
1823
  if (!connection) return socket.adapter.connected;
1685
1824
  clearTimeout(timeout);
1686
1825
  sse?.clearListeners();
1687
1826
  sse?.close();
1688
1827
  const eventSource = createEventSource(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), connection.adapterOptions);
1689
- sse = eventSource;
1828
+ sse = eventSource ?? void 0;
1690
1829
  if (!eventSource) return false;
1691
- timeout = setTimeout(() => {
1692
- reconnect();
1693
- }, socket.reconnectTime);
1830
+ const isCurrent = () => sse === eventSource;
1831
+ scheduleReconnect();
1694
1832
  /**
1695
1833
  * Mount listeners
1696
1834
  */
1697
1835
  eventSource.addEventListener("open", () => {
1836
+ if (!isCurrent()) return;
1698
1837
  clearTimeout(timeout);
1699
1838
  onConnected();
1700
1839
  });
1701
1840
  eventSource.addEventListener("error", (event) => {
1841
+ if (!isCurrent()) return;
1702
1842
  const error = getSocketError(event);
1703
1843
  onError({ error: new Error(error) });
1844
+ if (adapter.connected && eventSource.readyState !== EventSource.OPEN) {
1845
+ onDisconnected();
1846
+ if (eventSource.readyState === EventSource.CONNECTING) {
1847
+ adapter.setConnecting(true);
1848
+ socket.events.emitConnecting({ connecting: true });
1849
+ }
1850
+ scheduleReconnect();
1851
+ }
1704
1852
  });
1705
1853
  const { decode } = connection.adapterOptions || {};
1706
1854
  eventSource.addEventListener("message", (newEvent) => {
1855
+ if (!isCurrent()) return;
1707
1856
  const message = decodeMessage(newEvent, decode);
1708
1857
  if (message) onEvent({
1709
1858
  topic: message.topic,
@@ -1731,20 +1880,50 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1731
1880
  eventSource.addEventListener("error", resolveError, { disableCleanup: true });
1732
1881
  });
1733
1882
  };
1734
- const disconnect = async () => {
1883
+ const connect = () => {
1884
+ if (adapter.connecting && pendingConnection) return pendingConnection;
1885
+ const connection = openConnection();
1886
+ pendingConnection = connection;
1887
+ const release = () => {
1888
+ if (pendingConnection === connection) pendingConnection = void 0;
1889
+ };
1890
+ connection.then(release, release);
1891
+ return connection;
1892
+ };
1893
+ /**
1894
+ * Closes the transport and resets the connection state. From this point the closed transport is detached -
1895
+ * whatever it reports later does not reach the socket anymore.
1896
+ */
1897
+ const closeConnection = async ({ manual }) => {
1735
1898
  clearTimeout(timeout);
1736
1899
  const currentSse = sse;
1900
+ sse = void 0;
1737
1901
  const hasTransport = currentSse && currentSse.readyState !== EventSource.CLOSED;
1738
- const wasConnecting = adapter.connecting;
1902
+ const wasActive = adapter.connected || adapter.connecting;
1739
1903
  onDisconnect();
1740
- if (hasTransport) currentSse.close();
1741
- if (hasTransport || wasConnecting) onDisconnected();
1904
+ if (!manual) adapter.setForceClosed(false);
1905
+ if (hasTransport) {
1906
+ currentSse.clearListeners();
1907
+ currentSse.close();
1908
+ }
1909
+ if (hasTransport || wasActive) onDisconnected();
1742
1910
  return true;
1743
1911
  };
1744
- const reconnect = () => {
1745
- onReconnect({
1746
- disconnect,
1747
- connect
1912
+ /** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
1913
+ const disconnect = () => {
1914
+ return closeConnection({ manual: true });
1915
+ };
1916
+ const reconnect = async () => {
1917
+ adapter.setForceClosed(false);
1918
+ await onReconnect({
1919
+ disconnect: () => closeConnection({ manual: false }),
1920
+ connect: async () => {
1921
+ if (adapter.forceClosed) {
1922
+ adapter.setReconnectionAttempts(0);
1923
+ return false;
1924
+ }
1925
+ return connect();
1926
+ }
1748
1927
  });
1749
1928
  };
1750
1929
  /** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
@@ -1764,12 +1943,12 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1764
1943
  callback
1765
1944
  });
1766
1945
  };
1767
- const emit = async () => {
1946
+ const emit = () => {
1768
1947
  throw new Error("Cannot emit events in SSE adapter");
1769
1948
  };
1770
1949
  if (autoConnect) connect();
1771
1950
  socket.appManager.events.onOnline(() => {
1772
- if (autoConnect && !adapter.connected) connect();
1951
+ if (autoConnect && !adapter.connected && !adapter.forceClosed) connect();
1773
1952
  });
1774
1953
  return {
1775
1954
  connect,