@hyper-fetch/sockets 9.6.0 → 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 (40) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +63 -6
  3. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +45 -0
  4. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  5. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  6. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  7. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  8. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  9. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  10. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  11. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  12. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  13. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  14. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  15. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  16. package/__tests__/utils/controlled-event-source.ts +149 -0
  17. package/__tests__/utils/controlled-websocket.ts +213 -0
  18. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  19. package/dist/adapter/adapter.d.ts.map +1 -1
  20. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  21. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  22. package/dist/emitter/emitter.d.ts.map +1 -1
  23. package/dist/index.mjs +289 -105
  24. package/dist/index.mjs.map +1 -1
  25. package/dist/listener/listener.d.ts +2 -0
  26. package/dist/listener/listener.d.ts.map +1 -1
  27. package/dist/socket/socket.d.ts +1 -1
  28. package/dist/socket/socket.utils.d.ts +11 -3
  29. package/dist/socket/socket.utils.d.ts.map +1 -1
  30. package/dist/utils/topic.utils.d.ts +10 -0
  31. package/dist/utils/topic.utils.d.ts.map +1 -0
  32. package/package.json +1 -1
  33. package/src/adapter/adapter.bindings.ts +44 -20
  34. package/src/adapter/adapter.ts +29 -10
  35. package/src/adapter-sse/sse-adapter.ts +101 -13
  36. package/src/adapter-websockets/websocket-adapter.ts +126 -41
  37. package/src/emitter/emitter.ts +16 -9
  38. package/src/listener/listener.ts +7 -8
  39. package/src/socket/socket.utils.ts +20 -6
  40. 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({
@@ -503,6 +548,7 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
503
548
  });
504
549
  return new Promise((resolve) => {
505
550
  if (newWebsocket.readyState === WebSocket.OPEN) {
551
+ clearTimeout(timeout);
506
552
  resolve(true);
507
553
  socket.adapter.setConnected(true);
508
554
  socket.adapter.setConnecting(false);
@@ -525,31 +571,55 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
525
571
  newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
526
572
  });
527
573
  };
528
- 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 }) => {
529
590
  clearTimeout(timeout);
591
+ clearTimers();
530
592
  const currentWebsocket = websocket;
531
- if (!(currentWebsocket && currentWebsocket.readyState !== WebSocket.CLOSED)) {
532
- const wasConnecting = socket.adapter.connecting;
533
- onDisconnect();
534
- if (wasConnecting) onDisconnected();
535
- return true;
536
- }
537
- 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) => {
538
600
  const resolveDisconnected = () => {
539
601
  resolve(true);
540
602
  currentWebsocket.removeEventListener("close", resolveDisconnected);
541
603
  };
542
604
  currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
605
+ currentWebsocket.close(1e3);
543
606
  });
544
- onDisconnect();
545
- currentWebsocket.close(1e3);
546
- clearTimers();
547
- return promise;
607
+ };
608
+ /** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
609
+ const disconnect = () => {
610
+ return closeConnection({ manual: true });
548
611
  };
549
612
  const reconnect = async () => {
613
+ socket.adapter.setForceClosed(false);
550
614
  await onReconnect({
551
- disconnect,
552
- 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
+ }
553
623
  });
554
624
  };
555
625
  /** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
@@ -581,8 +651,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
581
651
  return null;
582
652
  }
583
653
  };
654
+ /** Encodes and sends a message. Returns the error instead of throwing, so callers decide how to report it. */
584
655
  const sendEventMessage = ({ topic, payload }) => {
585
- if (!websocket) return false;
656
+ if (!websocket) return /* @__PURE__ */ new Error("Cannot send event when connection is not open");
586
657
  try {
587
658
  const frame = options?.encode ? options.encode({
588
659
  topic,
@@ -592,10 +663,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
592
663
  data: payload
593
664
  });
594
665
  websocket.send(frame);
595
- return true;
666
+ return null;
596
667
  } catch (error) {
597
- onError({ error });
598
- return false;
668
+ return error instanceof Error ? error : new Error(String(error));
599
669
  }
600
670
  };
601
671
  const onHeartbeat = () => {
@@ -605,15 +675,31 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
605
675
  if (socket.adapter.connecting || !heartbeat) return;
606
676
  clearTimers();
607
677
  pingTimer = setTimeout(() => {
608
- sendEventMessage({
678
+ const error = sendEventMessage({
609
679
  topic: "heartbeat",
610
680
  payload: heartbeatMessage
611
681
  });
682
+ if (error) onError({ error });
612
683
  pongTimer = setTimeout(() => {
613
- websocket?.close();
684
+ onHeartbeatTimeout();
614
685
  }, pongTimeout);
615
686
  }, pingTimeout);
616
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
+ };
617
703
  const listen = (listener, callback) => {
618
704
  return onListen({
619
705
  listener,
@@ -623,11 +709,20 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
623
709
  const emit = async (emitter) => {
624
710
  const mappedEmitter = await onEmit({ emitter });
625
711
  if (!mappedEmitter) return;
626
- 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;
627
722
  };
628
723
  if (autoConnect) connect();
629
724
  socket.appManager.events.onOnline(() => {
630
- if (autoConnect && !socket.adapter.connected) connect();
725
+ if (autoConnect && !socket.adapter.connected && !socket.adapter.forceClosed) connect();
631
726
  });
632
727
  return {
633
728
  connect,
@@ -638,6 +733,24 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
638
733
  };
639
734
  });
640
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
641
754
  //#region src/emitter/emitter.ts
642
755
  /**
643
756
  * Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
@@ -678,11 +791,7 @@ var Emitter = class Emitter {
678
791
  return this.clone({ params });
679
792
  }
680
793
  paramsMapper = (params) => {
681
- let topic = this.emitterOptions.topic;
682
- if (params) Object.entries(params).forEach(([key, value]) => {
683
- topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
684
- });
685
- return topic;
794
+ return mapTopicParams(this.emitterOptions.topic, params);
686
795
  };
687
796
  /** Create a new emitter instance with optional configuration overrides. */
688
797
  clone(config) {
@@ -701,7 +810,18 @@ var Emitter = class Emitter {
701
810
  emit = (options = {}) => {
702
811
  const typedOptions = options;
703
812
  const instance = this.clone(typedOptions);
704
- 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
+ });
705
825
  };
706
826
  };
707
827
  //#endregion
@@ -1185,11 +1305,14 @@ var Listener = class Listener {
1185
1305
  delivery = void 0;
1186
1306
  /** Stored with an `any` response for the same covariance reason as `delivery`. */
1187
1307
  listenerOptions;
1308
+ /** Topic as it was declared (e.g. `chat/:roomId`) - clones keep it, so params can be set again */
1309
+ topicTemplate;
1188
1310
  constructor(socket, listenerOptions) {
1189
1311
  this.socket = socket;
1190
1312
  this.listenerOptions = listenerOptions;
1191
1313
  const { topic, options, delivery, params } = listenerOptions;
1192
1314
  this.topic = topic;
1315
+ this.topicTemplate = topic;
1193
1316
  this.options = options;
1194
1317
  this.params = params;
1195
1318
  this.delivery = delivery;
@@ -1212,11 +1335,13 @@ var Listener = class Listener {
1212
1335
  }
1213
1336
  /** Create a new listener instance with optional configuration overrides. */
1214
1337
  clone(options) {
1215
- return new Listener(this.socket, {
1338
+ const newInstance = new Listener(this.socket, {
1216
1339
  ...this.listenerOptions,
1217
1340
  ...options,
1218
1341
  topic: this.paramsMapper(options?.params || this.params)
1219
1342
  });
1343
+ newInstance.topicTemplate = this.topicTemplate;
1344
+ return newInstance;
1220
1345
  }
1221
1346
  /** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
1222
1347
  listen = (callback) => {
@@ -1233,11 +1358,7 @@ var Listener = class Listener {
1233
1358
  return removeListener;
1234
1359
  };
1235
1360
  paramsMapper = (params) => {
1236
- let topic = this.listenerOptions.topic;
1237
- if (params) Object.entries(params).forEach(([key, value]) => {
1238
- topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
1239
- });
1240
- return topic;
1361
+ return mapTopicParams(this.topicTemplate, params);
1241
1362
  };
1242
1363
  };
1243
1364
  //#endregion
@@ -1472,18 +1593,30 @@ var getListenerRemoveByTopicKey = (event) => `${event}_listener_remove`;
1472
1593
  var getListenerEventByTopicKey = (event) => `${event}_listener_event`;
1473
1594
  var getEmitterStartEventByTopicKey = (event) => `${event}_emitter_start_event`;
1474
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
+ */
1475
1600
  var interceptListener = (interceptors, event) => {
1476
- let newResponse = event;
1601
+ let { data } = event;
1477
1602
  for (const interceptor of interceptors) {
1478
- newResponse = interceptor({ event: event.data });
1479
- 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;
1480
1606
  }
1481
- return newResponse;
1607
+ return {
1608
+ data,
1609
+ extra: event.extra
1610
+ };
1482
1611
  };
1612
+ /**
1613
+ * Runs the `onSend` interceptors over an emitter. Every interceptor receives the emitter
1614
+ * returned by the previous one.
1615
+ */
1483
1616
  var interceptEmitter = (interceptors, emitter) => {
1484
1617
  let newEmitter = emitter;
1485
1618
  for (const interceptor of interceptors) {
1486
- newEmitter = interceptor({ emitter });
1619
+ newEmitter = interceptor({ emitter: newEmitter });
1487
1620
  if (!newEmitter) throw new Error("Send modifier must return emitter");
1488
1621
  }
1489
1622
  return newEmitter;
@@ -1662,6 +1795,8 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
1662
1795
  /** Create a preconfigured socket adapter for Server-Sent Events (EventSource) connections. */
1663
1796
  var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, adapter, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onConnected, onDisconnected, onError, onEvent }) => {
1664
1797
  let sse;
1798
+ let pendingConnection;
1799
+ let timeout;
1665
1800
  const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
1666
1801
  /** Maps an incoming message to the listener event, reporting decoder failures instead of throwing */
1667
1802
  const decodeMessage = (event, decode) => {
@@ -1677,30 +1812,47 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1677
1812
  return null;
1678
1813
  }
1679
1814
  };
1680
- const connect = async () => {
1815
+ const scheduleReconnect = () => {
1816
+ clearTimeout(timeout);
1817
+ timeout = setTimeout(() => {
1818
+ reconnect();
1819
+ }, socket.reconnectTime);
1820
+ };
1821
+ const openConnection = async () => {
1681
1822
  const connection = await onConnect();
1682
1823
  if (!connection) return socket.adapter.connected;
1824
+ clearTimeout(timeout);
1683
1825
  sse?.clearListeners();
1684
1826
  sse?.close();
1685
1827
  const eventSource = createEventSource(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), connection.adapterOptions);
1686
- sse = eventSource;
1828
+ sse = eventSource ?? void 0;
1687
1829
  if (!eventSource) return false;
1688
- const timeout = setTimeout(() => {
1689
- reconnect();
1690
- }, socket.reconnectTime);
1830
+ const isCurrent = () => sse === eventSource;
1831
+ scheduleReconnect();
1691
1832
  /**
1692
1833
  * Mount listeners
1693
1834
  */
1694
1835
  eventSource.addEventListener("open", () => {
1836
+ if (!isCurrent()) return;
1695
1837
  clearTimeout(timeout);
1696
1838
  onConnected();
1697
1839
  });
1698
1840
  eventSource.addEventListener("error", (event) => {
1841
+ if (!isCurrent()) return;
1699
1842
  const error = getSocketError(event);
1700
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
+ }
1701
1852
  });
1702
1853
  const { decode } = connection.adapterOptions || {};
1703
1854
  eventSource.addEventListener("message", (newEvent) => {
1855
+ if (!isCurrent()) return;
1704
1856
  const message = decodeMessage(newEvent, decode);
1705
1857
  if (message) onEvent({
1706
1858
  topic: message.topic,
@@ -1710,6 +1862,7 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1710
1862
  });
1711
1863
  return new Promise((resolve) => {
1712
1864
  if (eventSource.readyState === EventSource.OPEN) {
1865
+ clearTimeout(timeout);
1713
1866
  resolve(true);
1714
1867
  adapter.setConnected(true);
1715
1868
  adapter.setConnecting(false);
@@ -1727,19 +1880,50 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1727
1880
  eventSource.addEventListener("error", resolveError, { disableCleanup: true });
1728
1881
  });
1729
1882
  };
1730
- 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 }) => {
1898
+ clearTimeout(timeout);
1731
1899
  const currentSse = sse;
1900
+ sse = void 0;
1732
1901
  const hasTransport = currentSse && currentSse.readyState !== EventSource.CLOSED;
1733
- const wasConnecting = adapter.connecting;
1902
+ const wasActive = adapter.connected || adapter.connecting;
1734
1903
  onDisconnect();
1735
- if (hasTransport) currentSse.close();
1736
- 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();
1737
1910
  return true;
1738
1911
  };
1739
- const reconnect = () => {
1740
- onReconnect({
1741
- disconnect,
1742
- 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
+ }
1743
1927
  });
1744
1928
  };
1745
1929
  /** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
@@ -1759,12 +1943,12 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1759
1943
  callback
1760
1944
  });
1761
1945
  };
1762
- const emit = async () => {
1946
+ const emit = () => {
1763
1947
  throw new Error("Cannot emit events in SSE adapter");
1764
1948
  };
1765
1949
  if (autoConnect) connect();
1766
1950
  socket.appManager.events.onOnline(() => {
1767
- if (autoConnect && !adapter.connected) connect();
1951
+ if (autoConnect && !adapter.connected && !adapter.forceClosed) connect();
1768
1952
  });
1769
1953
  return {
1770
1954
  connect,