@hyper-fetch/sockets 6.0.0 → 7.0.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 (41) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +6 -6
  3. package/dist/index.d.ts +523 -296
  4. package/dist/index.js +1246 -0
  5. package/dist/index.js.map +7 -0
  6. package/package.json +8 -9
  7. package/src/adapter/adapter.bindings.ts +128 -101
  8. package/src/adapter/adapter.ts +231 -0
  9. package/src/adapter/adapter.types.ts +10 -101
  10. package/src/adapter/index.ts +4 -4
  11. package/src/adapter-sse/index.ts +3 -0
  12. package/src/adapter-sse/sse-adapter.ts +192 -0
  13. package/src/adapter-sse/sse-adapter.types.ts +6 -0
  14. package/src/adapter-sse/sse-adapter.utils.ts +77 -0
  15. package/src/adapter-websockets/index.ts +3 -0
  16. package/src/adapter-websockets/websocket-adapter.ts +259 -0
  17. package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
  18. package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
  19. package/src/emitter/emitter.ts +60 -102
  20. package/src/emitter/emitter.types.ts +82 -49
  21. package/src/index.ts +3 -0
  22. package/src/listener/listener.ts +34 -49
  23. package/src/listener/listener.types.ts +69 -17
  24. package/src/socket/socket.events.ts +147 -112
  25. package/src/socket/socket.ts +78 -100
  26. package/src/socket/socket.types.ts +13 -18
  27. package/src/socket/socket.utils.ts +12 -14
  28. package/src/types/connect.types.ts +2 -2
  29. package/src/types/extract.types.ts +43 -10
  30. package/src/utils/index.ts +3 -0
  31. package/src/utils/message-event.utils.ts +6 -0
  32. package/src/utils/socket.errors.ts +48 -0
  33. package/src/utils/socket.utils.ts +4 -0
  34. package/tsconfig.json +7 -3
  35. package/dist/index.cjs.js +0 -853
  36. package/dist/index.cjs.js.map +0 -7
  37. package/dist/index.esm.js +0 -833
  38. package/dist/index.esm.js.map +0 -7
  39. package/src/adapter/adapter.sse.ts +0 -127
  40. package/src/adapter/adapter.utils.ts +0 -20
  41. package/src/adapter/adapter.websocket.ts +0 -187
package/dist/index.js ADDED
@@ -0,0 +1,1246 @@
1
+ var __defProp = Object.defineProperty;
2
+ var __defProps = Object.defineProperties;
3
+ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
4
+ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
5
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
6
+ var __propIsEnum = Object.prototype.propertyIsEnumerable;
7
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
8
+ var __spreadValues = (a, b) => {
9
+ for (var prop in b || (b = {}))
10
+ if (__hasOwnProp.call(b, prop))
11
+ __defNormalProp(a, prop, b[prop]);
12
+ if (__getOwnPropSymbols)
13
+ for (var prop of __getOwnPropSymbols(b)) {
14
+ if (__propIsEnum.call(b, prop))
15
+ __defNormalProp(a, prop, b[prop]);
16
+ }
17
+ return a;
18
+ };
19
+ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
20
+ var __publicField = (obj, key, value) => {
21
+ __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
22
+ return value;
23
+ };
24
+ var __async = (__this, __arguments, generator) => {
25
+ return new Promise((resolve, reject) => {
26
+ var fulfilled = (value) => {
27
+ try {
28
+ step(generator.next(value));
29
+ } catch (e) {
30
+ reject(e);
31
+ }
32
+ };
33
+ var rejected = (value) => {
34
+ try {
35
+ step(generator.throw(value));
36
+ } catch (e) {
37
+ reject(e);
38
+ }
39
+ };
40
+ var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
41
+ step((generator = generator.apply(__this, __arguments)).next());
42
+ });
43
+ };
44
+
45
+ // src/socket/socket.ts
46
+ import EventEmitter from "events";
47
+ import { LoggerManager, AppManager, Time as Time2 } from "@hyper-fetch/core";
48
+
49
+ // src/listener/listener.ts
50
+ var Listener = class _Listener {
51
+ constructor(socket, listenerOptions) {
52
+ this.socket = socket;
53
+ this.listenerOptions = listenerOptions;
54
+ __publicField(this, "topic");
55
+ __publicField(this, "params");
56
+ __publicField(this, "options");
57
+ __publicField(this, "listen", (callback) => {
58
+ this.socket.adapter.listen(this, callback);
59
+ const removeListener = () => {
60
+ this.socket.adapter.removeListener({ topic: this.topic, callback });
61
+ };
62
+ return removeListener;
63
+ });
64
+ __publicField(this, "paramsMapper", (params) => {
65
+ let topic = this.listenerOptions.topic;
66
+ if (params) {
67
+ Object.entries(params).forEach(([key, value]) => {
68
+ topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
69
+ });
70
+ }
71
+ return topic;
72
+ });
73
+ const { topic, options } = listenerOptions;
74
+ this.topic = topic;
75
+ this.options = options;
76
+ }
77
+ setOptions(options) {
78
+ return this.clone({ options });
79
+ }
80
+ setParams(params) {
81
+ return this.clone({ params });
82
+ }
83
+ clone(options) {
84
+ const newInstance = new _Listener(this.socket, __spreadProps(__spreadValues(__spreadValues({}, this.listenerOptions), options), {
85
+ topic: this.paramsMapper((options == null ? void 0 : options.params) || this.params)
86
+ }));
87
+ return newInstance;
88
+ }
89
+ };
90
+
91
+ // src/emitter/emitter.ts
92
+ var Emitter = class _Emitter {
93
+ constructor(socket, emitterOptions, snapshot) {
94
+ this.socket = socket;
95
+ this.emitterOptions = emitterOptions;
96
+ __publicField(this, "topic");
97
+ __publicField(this, "params");
98
+ __publicField(this, "payload");
99
+ __publicField(this, "options");
100
+ /** @internal */
101
+ __publicField(this, "unstable_payloadMapper");
102
+ __publicField(this, "setPayload", (payload) => {
103
+ return this.clone({
104
+ payload
105
+ });
106
+ });
107
+ __publicField(this, "setPayloadMapper", (payloadMapper) => {
108
+ const cloned = this.clone(void 0);
109
+ cloned.unstable_payloadMapper = payloadMapper;
110
+ return cloned;
111
+ });
112
+ __publicField(this, "paramsMapper", (params) => {
113
+ let topic = this.emitterOptions.topic;
114
+ if (params) {
115
+ Object.entries(params).forEach(([key, value]) => {
116
+ topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
117
+ });
118
+ }
119
+ return topic;
120
+ });
121
+ __publicField(this, "emit", (options = {}) => {
122
+ const typedOptions = options;
123
+ const instance = this.clone(typedOptions);
124
+ this.socket.adapter.emit(instance);
125
+ });
126
+ var _a, _b;
127
+ const { topic, options } = emitterOptions;
128
+ this.topic = (_a = snapshot == null ? void 0 : snapshot.topic) != null ? _a : topic;
129
+ this.payload = snapshot == null ? void 0 : snapshot.payload;
130
+ this.options = (_b = snapshot == null ? void 0 : snapshot.options) != null ? _b : options;
131
+ this.params = snapshot == null ? void 0 : snapshot.params;
132
+ }
133
+ setOptions(options) {
134
+ return this.clone({ options });
135
+ }
136
+ setParams(params) {
137
+ return this.clone({ params });
138
+ }
139
+ clone(config) {
140
+ const snapshot = __spreadProps(__spreadValues({
141
+ options: this.options,
142
+ payload: this.payload
143
+ }, config), {
144
+ params: (config == null ? void 0 : config.params) || this.params,
145
+ topic: this.paramsMapper((config == null ? void 0 : config.params) || this.params)
146
+ });
147
+ const newInstance = new _Emitter(
148
+ this.socket,
149
+ this.emitterOptions,
150
+ snapshot
151
+ );
152
+ newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
153
+ return newInstance;
154
+ }
155
+ };
156
+
157
+ // src/adapter-websockets/websocket-adapter.ts
158
+ import { stringifyQueryParams, Time } from "@hyper-fetch/core";
159
+
160
+ // src/adapter/adapter.ts
161
+ import {
162
+ defaultMapper
163
+ } from "@hyper-fetch/core";
164
+
165
+ // src/adapter/adapter.bindings.ts
166
+ var getAdapterBindings = (socket) => {
167
+ const { adapter } = socket;
168
+ const logger = socket.loggerManager.initialize(socket, "Socket Bindings");
169
+ const onConnect = () => {
170
+ if (!socket.appManager.isOnline || adapter.connecting) {
171
+ logger.warning({
172
+ title: "Cannot initialize adapter.",
173
+ type: "system",
174
+ extra: {
175
+ connecting: adapter.connecting,
176
+ online: socket.appManager.isOnline
177
+ }
178
+ });
179
+ return false;
180
+ }
181
+ socket.adapter.setForceClosed(false);
182
+ socket.adapter.setConnecting(true);
183
+ socket.adapter.setReconnectionAttempts(0);
184
+ socket.events.emitConnecting({ connecting: true });
185
+ return true;
186
+ };
187
+ const onDisconnect = () => {
188
+ logger.debug({
189
+ title: "Disconnecting",
190
+ type: "system",
191
+ extra: { reconnectionAttempts: adapter.reconnectionAttempts }
192
+ });
193
+ socket.adapter.setConnected(false);
194
+ socket.adapter.setConnecting(false);
195
+ socket.adapter.setForceClosed(true);
196
+ socket.adapter.setReconnectionAttempts(0);
197
+ return true;
198
+ };
199
+ const onReconnect = (_0) => __async(void 0, [_0], function* ({
200
+ disconnect,
201
+ connect
202
+ }) {
203
+ socket.unstable_onReconnectCallbacks.forEach((callback) => {
204
+ callback();
205
+ });
206
+ socket.events.emitReconnecting({ attempts: adapter.reconnectionAttempts });
207
+ yield disconnect();
208
+ if (adapter.reconnectionAttempts < socket.reconnectAttempts) {
209
+ socket.adapter.setReconnectionAttempts(adapter.reconnectionAttempts + 1);
210
+ logger.debug({
211
+ title: "Reconnecting",
212
+ type: "system",
213
+ extra: { reconnectionAttempts: adapter.reconnectionAttempts }
214
+ });
215
+ yield connect();
216
+ return true;
217
+ }
218
+ logger.error({
219
+ title: "Stopped reconnecting",
220
+ type: "system",
221
+ extra: { reconnectionAttempts: adapter.reconnectionAttempts }
222
+ });
223
+ socket.unstable_onReconnectFailedCallbacks.forEach((callback) => {
224
+ callback();
225
+ });
226
+ socket.events.emitReconnectingFailed({ attempts: adapter.reconnectionAttempts });
227
+ return false;
228
+ });
229
+ const onListen = ({
230
+ listener,
231
+ callback,
232
+ onUnmount = () => null
233
+ }) => {
234
+ const listenerGroup = adapter.listeners.get(listener.topic) || adapter.listeners.set(listener.topic, /* @__PURE__ */ new Map()).get(listener.topic);
235
+ listenerGroup.set(callback, onUnmount);
236
+ return () => socket.adapter.removeListener({ topic: listener.topic, callback });
237
+ };
238
+ const onEmit = (_0) => __async(void 0, [_0], function* ({ emitter }) {
239
+ if (adapter.connecting || !adapter.connected) {
240
+ logger.error({ title: "Cannot emit event when connection is not open", type: "system", extra: {} });
241
+ return null;
242
+ }
243
+ emitter.payload = emitter.unstable_payloadMapper ? emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
244
+ const emitterInstance = yield socket.unstable__modifySend(emitter);
245
+ socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
246
+ return emitterInstance;
247
+ });
248
+ const onEmitError = ({ emitter, error }) => {
249
+ socket.events.emitEmitterError({ error, emitter });
250
+ };
251
+ const onConnected = () => {
252
+ logger.info({ title: "Connection open", type: "system", extra: {} });
253
+ adapter.setConnected(true);
254
+ adapter.setConnecting(false);
255
+ socket.events.emitConnecting({ connecting: false });
256
+ socket.events.emitConnected();
257
+ socket.unstable_onConnectedCallbacks.forEach((callback) => {
258
+ callback();
259
+ });
260
+ };
261
+ const onDisconnected = () => {
262
+ logger.info({ title: "Connection closed", type: "system", extra: {} });
263
+ adapter.setConnected(false);
264
+ adapter.setConnecting(false);
265
+ socket.events.emitConnecting({ connecting: false });
266
+ socket.events.emitDisconnected();
267
+ socket.unstable_onDisconnectCallbacks.forEach((callback) => {
268
+ callback();
269
+ });
270
+ };
271
+ const onError = ({ error }) => {
272
+ logger.info({ title: "Error message", type: "system", extra: { error } });
273
+ socket.unstable_onErrorCallbacks.forEach((callback) => {
274
+ callback({ error });
275
+ });
276
+ socket.events.emitError({ error });
277
+ };
278
+ const onEvent = ({ topic, data, extra }) => {
279
+ logger.info({ title: "New event message", type: "system", extra: { topic, data, extra } });
280
+ const { data: modifiedData, extra: modifiedExtra } = socket.unstable__modifyResponse({ data, extra });
281
+ socket.adapter.triggerListeners({ topic, data: modifiedData, extra: modifiedExtra });
282
+ socket.events.emitListenerEvent({ topic, data: modifiedData, extra: modifiedExtra });
283
+ };
284
+ const getQueryParams = () => socket.adapter.unstable_queryParamsMapper(socket.adapter.queryParams, socket.adapter.queryParamsConfig);
285
+ return {
286
+ socket,
287
+ adapter: socket.adapter,
288
+ logger,
289
+ getQueryParams,
290
+ onConnect,
291
+ onReconnect,
292
+ onDisconnect,
293
+ onListen,
294
+ onEmit,
295
+ onEmitError,
296
+ onConnected,
297
+ onDisconnected,
298
+ onError,
299
+ onEvent
300
+ };
301
+ };
302
+
303
+ // src/adapter/adapter.ts
304
+ var SocketAdapter = class {
305
+ constructor(options) {
306
+ this.options = options;
307
+ __publicField(this, "name");
308
+ __publicField(this, "socket");
309
+ __publicField(this, "defaultExtra");
310
+ __publicField(this, "queryParams");
311
+ __publicField(this, "queryParamsConfig");
312
+ /** Config for the query params mapper */
313
+ __publicField(this, "unstable_queryParamsMapperConfig");
314
+ /** Method to get request data and transform them to the required format. */
315
+ __publicField(this, "unstable_queryParamsMapper", defaultMapper);
316
+ __publicField(this, "adapterOptions");
317
+ __publicField(this, "listenerOptions");
318
+ __publicField(this, "emitterOptions");
319
+ __publicField(this, "getConnector");
320
+ // State
321
+ __publicField(this, "connected", false);
322
+ __publicField(this, "connecting", false);
323
+ __publicField(this, "reconnectionAttempts", 0);
324
+ __publicField(this, "forceClosed", false);
325
+ // Listeners
326
+ __publicField(this, "listeners", /* @__PURE__ */ new Map());
327
+ __publicField(this, "listen");
328
+ __publicField(this, "emit");
329
+ __publicField(this, "connect");
330
+ __publicField(this, "reconnect");
331
+ __publicField(this, "disconnect");
332
+ __publicField(this, "setQueryParamsMapperConfig", (config) => {
333
+ this.unstable_queryParamsMapperConfig = config;
334
+ return this;
335
+ });
336
+ /**
337
+ * Set the query params mapping function which get triggered before request get sent
338
+ */
339
+ __publicField(this, "setQueryParamsMapper", (queryParamsMapper) => {
340
+ this.unstable_queryParamsMapper = (queryParams) => queryParamsMapper(
341
+ queryParams,
342
+ this.unstable_queryParamsMapperConfig
343
+ );
344
+ return this;
345
+ });
346
+ // Listeners
347
+ __publicField(this, "removeListener", ({
348
+ topic,
349
+ callback
350
+ }) => {
351
+ const listenerGroup = this.listeners.get(topic);
352
+ if (listenerGroup) {
353
+ const unmount = listenerGroup.get(callback);
354
+ this.socket.events.emitListenerRemoveEvent({ topic });
355
+ listenerGroup.delete(callback);
356
+ unmount == null ? void 0 : unmount();
357
+ return true;
358
+ }
359
+ return false;
360
+ });
361
+ __publicField(this, "triggerListeners", ({
362
+ topic,
363
+ data,
364
+ extra
365
+ }) => {
366
+ const listenerGroup = this.listeners.get(topic);
367
+ if (listenerGroup) {
368
+ listenerGroup.forEach((_, action) => {
369
+ action({ data, extra });
370
+ });
371
+ }
372
+ });
373
+ // State
374
+ __publicField(this, "setConnected", (connected) => {
375
+ this.connected = connected;
376
+ return this;
377
+ });
378
+ __publicField(this, "setConnecting", (connecting) => {
379
+ this.connecting = connecting;
380
+ return this;
381
+ });
382
+ __publicField(this, "setReconnectionAttempts", (reconnectionAttempts) => {
383
+ this.reconnectionAttempts = reconnectionAttempts;
384
+ return this;
385
+ });
386
+ __publicField(this, "setForceClosed", (forceClosed) => {
387
+ this.forceClosed = forceClosed;
388
+ return this;
389
+ });
390
+ // Connector
391
+ __publicField(this, "setConnector", (connector) => {
392
+ this.getConnector = () => {
393
+ const bindings = getAdapterBindings(this.socket);
394
+ return connector(bindings);
395
+ };
396
+ return this;
397
+ });
398
+ this.name = options.name;
399
+ this.queryParams = options.queryParams;
400
+ if (options.defaultConnected) {
401
+ this.setConnected(options.defaultConnected);
402
+ }
403
+ if (options.defaultConnecting) {
404
+ this.setConnecting(options.defaultConnecting);
405
+ }
406
+ if (options.defaultReconnectionAttempts) {
407
+ this.setReconnectionAttempts(options.defaultReconnectionAttempts);
408
+ }
409
+ if (options.defaultForceClosed) {
410
+ this.setForceClosed(options.defaultForceClosed);
411
+ }
412
+ }
413
+ initialize(socket) {
414
+ this.socket = socket;
415
+ this.adapterOptions = __spreadValues(__spreadValues({}, this.adapterOptions), socket.options.adapterOptions);
416
+ const { listen, emit, connect, reconnect, disconnect } = this.getConnector();
417
+ this.listen = listen;
418
+ this.emit = emit;
419
+ this.connect = connect;
420
+ this.reconnect = reconnect;
421
+ this.disconnect = disconnect;
422
+ return this;
423
+ }
424
+ setQueryParams(queryParams) {
425
+ this.queryParams = queryParams;
426
+ return this;
427
+ }
428
+ setQueryParamsConfig(queryParamsConfig) {
429
+ this.queryParamsConfig = queryParamsConfig;
430
+ return this;
431
+ }
432
+ setDefaultExtra(defaultExtra) {
433
+ this.defaultExtra = defaultExtra;
434
+ return this;
435
+ }
436
+ setOptions(adapterOptions) {
437
+ this.adapterOptions = adapterOptions;
438
+ return this;
439
+ }
440
+ setDefaultListenerOptions(listenerOptions) {
441
+ this.listenerOptions = listenerOptions;
442
+ return this;
443
+ }
444
+ setDefaultEmitterOptions(emitterOptions) {
445
+ this.emitterOptions = emitterOptions;
446
+ return this;
447
+ }
448
+ };
449
+
450
+ // src/adapter-websockets/websocket-adapter.utils.ts
451
+ var getWebsocketAdapter = (url, adapterOptions) => {
452
+ try {
453
+ if (!(window == null ? void 0 : window.WebSocket))
454
+ return null;
455
+ } catch (error) {
456
+ return null;
457
+ }
458
+ class HyperFetchWebsocket extends WebSocket {
459
+ // eslint-disable-next-line @typescript-eslint/no-useless-constructor
460
+ constructor(socketUrl, protocols) {
461
+ super(socketUrl, protocols);
462
+ __publicField(this, "listeners", /* @__PURE__ */ new Map());
463
+ __publicField(this, "addEventListener", (type, listener, options) => {
464
+ super.addEventListener(type, listener, options);
465
+ this.listeners.set(listener, { type, listener, options });
466
+ });
467
+ __publicField(this, "removeEventListener", (type, listener, options) => {
468
+ super.removeEventListener(type, listener, options);
469
+ this.listeners.delete(listener);
470
+ });
471
+ __publicField(this, "clearListeners", () => {
472
+ this.listeners.forEach(({ type, listener, options }) => {
473
+ if (!(options == null ? void 0 : options.disableCleanup)) {
474
+ this.removeEventListener(type, listener, options);
475
+ }
476
+ });
477
+ });
478
+ }
479
+ }
480
+ return new HyperFetchWebsocket(url, adapterOptions == null ? void 0 : adapterOptions.protocols);
481
+ };
482
+
483
+ // src/utils/message-event.utils.ts
484
+ import { parseResponse } from "@hyper-fetch/core";
485
+ var parseMessageEvent = (event) => {
486
+ const parsedEvent = parseResponse(event.data);
487
+ return __spreadProps(__spreadValues({}, parsedEvent), { event });
488
+ };
489
+
490
+ // src/utils/socket.utils.ts
491
+ var getSocketUrl = (url, queryParams) => {
492
+ const fullUrl = `${url}${queryParams}`;
493
+ return fullUrl;
494
+ };
495
+
496
+ // src/utils/socket.errors.ts
497
+ var getSocketError = (event) => {
498
+ if ("code" in event) {
499
+ switch (event.code) {
500
+ case 1e3:
501
+ return "Normal closure, meaning that the purpose for which the connection was established has been fulfilled.";
502
+ case 1001:
503
+ return 'An endpoint is "going away", such as a server going down or a browser having navigated away from a page.';
504
+ case 1002:
505
+ return "An endpoint is terminating the connection due to a protocol error";
506
+ case 1003:
507
+ return "An endpoint is terminating the connection because it has received a type of data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it receives a binary message).";
508
+ case 1004:
509
+ return "Reserved. The specific meaning might be defined in the future.";
510
+ case 1005:
511
+ return "No status code was actually present.";
512
+ case 1006:
513
+ return "The connection was closed abnormally, e.g., without sending or receiving a Close control frame";
514
+ case 1007:
515
+ return "An endpoint is terminating the connection because it has received data within a message that was not consistent with the type of the message (e.g., non-UTF-8 [https://www.rfc-editor.org/rfc/rfc3629] data within a text message).";
516
+ case 1008:
517
+ return 'An endpoint is terminating the connection because it has received a message that "violates its policy". This reason is given either if there is no other sutible reason, or if there is a need to hide specific details about the policy.';
518
+ case 1009:
519
+ return "An endpoint is terminating the connection because it has received a message that is too big for it to process.";
520
+ case 1010: {
521
+ const reason = "reason" in event ? event.reason : null;
522
+ return "An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. <br /> Specifically, the extensions that are needed are: " + (reason || "Unknown reason");
523
+ }
524
+ case 1011:
525
+ return "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.";
526
+ case 1015:
527
+ return "The connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified).";
528
+ default:
529
+ return "Unknown reason";
530
+ }
531
+ }
532
+ if ("data" in event) {
533
+ return JSON.stringify(event.data);
534
+ }
535
+ return "There was an socket error";
536
+ };
537
+
538
+ // src/adapter-websockets/websocket-adapter.ts
539
+ var WebsocketAdapter = () => new SocketAdapter({
540
+ name: "websockets"
541
+ }).setQueryParamsMapper(stringifyQueryParams).setConnector(
542
+ ({
543
+ socket,
544
+ logger,
545
+ getQueryParams,
546
+ onConnect,
547
+ onReconnect,
548
+ onDisconnect,
549
+ onListen,
550
+ onEmit,
551
+ onConnected,
552
+ onDisconnected,
553
+ onError,
554
+ onEvent
555
+ }) => {
556
+ var _a, _b;
557
+ const autoConnect = typeof ((_a = socket.adapter.adapterOptions) == null ? void 0 : _a.autoConnect) === "boolean" ? (_b = socket.adapter.adapterOptions) == null ? void 0 : _b.autoConnect : true;
558
+ let websocket;
559
+ let pingTimer;
560
+ let pongTimer;
561
+ let timeout;
562
+ const connect = () => __async(void 0, null, function* () {
563
+ const url = getSocketUrl(socket.url, getQueryParams());
564
+ const enabled = onConnect();
565
+ if (!enabled) {
566
+ return Promise.resolve(false);
567
+ }
568
+ clearTimeout(timeout);
569
+ websocket == null ? void 0 : websocket.clearListeners();
570
+ websocket == null ? void 0 : websocket.close(1e3);
571
+ const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
572
+ websocket = newWebsocket;
573
+ if (!newWebsocket) {
574
+ logger.error({
575
+ title: "Cannot connect to websocket",
576
+ type: "system",
577
+ extra: {
578
+ websocket
579
+ }
580
+ });
581
+ return Promise.resolve(false);
582
+ }
583
+ newWebsocket.clearListeners();
584
+ timeout = setTimeout(() => {
585
+ reconnect();
586
+ }, socket.reconnectTime);
587
+ newWebsocket.addEventListener("open", () => {
588
+ clearTimeout(timeout);
589
+ onConnected();
590
+ onHeartbeat();
591
+ });
592
+ newWebsocket.addEventListener("close", (event) => {
593
+ clearTimeout(timeout);
594
+ onDisconnected();
595
+ clearTimers();
596
+ const error = getSocketError(event);
597
+ onError({ error: new Error(error) });
598
+ if (event.code !== 1e3) {
599
+ timeout = setTimeout(() => {
600
+ reconnect();
601
+ }, socket.reconnectTime);
602
+ }
603
+ });
604
+ newWebsocket.addEventListener("message", (newEvent) => {
605
+ const { topic, data, event } = parseMessageEvent(newEvent);
606
+ onEvent({ topic, data, extra: event });
607
+ onHeartbeat();
608
+ });
609
+ return new Promise((resolve) => {
610
+ if (newWebsocket.readyState === WebSocket.OPEN) {
611
+ resolve(true);
612
+ socket.adapter.setConnected(true);
613
+ socket.adapter.setConnecting(false);
614
+ return;
615
+ }
616
+ const resolveConnected = () => {
617
+ resolve(true);
618
+ newWebsocket.removeEventListener("open", resolveConnected);
619
+ };
620
+ const resolveDisconnected = () => {
621
+ resolve(false);
622
+ newWebsocket.removeEventListener("close", resolveDisconnected);
623
+ };
624
+ const resolveError = () => {
625
+ resolve(false);
626
+ newWebsocket.removeEventListener("error", resolveError);
627
+ };
628
+ newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
629
+ newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
630
+ newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
631
+ });
632
+ });
633
+ const disconnect = () => __async(void 0, null, function* () {
634
+ if (!websocket) {
635
+ socket.adapter.setConnected(false);
636
+ socket.adapter.setConnecting(false);
637
+ return Promise.resolve(true);
638
+ }
639
+ const currentWebsocket = websocket;
640
+ const promise = new Promise((resolve) => {
641
+ if (currentWebsocket.readyState === WebSocket.CLOSED) {
642
+ resolve(true);
643
+ socket.adapter.setConnected(false);
644
+ socket.adapter.setConnecting(false);
645
+ return;
646
+ }
647
+ const resolveDisconnected = () => {
648
+ resolve(true);
649
+ currentWebsocket.removeEventListener("close", resolveDisconnected);
650
+ };
651
+ currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
652
+ });
653
+ onDisconnect();
654
+ currentWebsocket.close(1e3);
655
+ clearTimers();
656
+ return promise;
657
+ });
658
+ const reconnect = () => __async(void 0, null, function* () {
659
+ yield onReconnect({ disconnect, connect });
660
+ });
661
+ const clearTimers = () => {
662
+ clearTimeout(pingTimer);
663
+ clearTimeout(pongTimer);
664
+ };
665
+ const sendEventMessage = ({ topic, payload }) => {
666
+ if (!websocket)
667
+ return false;
668
+ websocket.send(JSON.stringify({ topic, data: payload }));
669
+ return true;
670
+ };
671
+ const onHeartbeat = () => {
672
+ const {
673
+ heartbeat = false,
674
+ pingTimeout = Time.SEC * 5,
675
+ pongTimeout = Time.SEC * 5,
676
+ heartbeatMessage = "heartbeat"
677
+ } = socket.adapter.adapterOptions || /* istanbul ignore next */
678
+ {};
679
+ if (socket.adapter.connecting || !heartbeat)
680
+ return;
681
+ clearTimers();
682
+ pingTimer = setTimeout(() => {
683
+ sendEventMessage({ topic: "heartbeat", payload: heartbeatMessage });
684
+ pongTimer = setTimeout(() => {
685
+ websocket == null ? void 0 : websocket.close();
686
+ }, pongTimeout);
687
+ }, pingTimeout);
688
+ };
689
+ const listen = (listener, callback) => {
690
+ return onListen({ listener, callback });
691
+ };
692
+ const emit = (emitter) => __async(void 0, null, function* () {
693
+ const mappedEmitter = yield onEmit({ emitter });
694
+ if (!mappedEmitter)
695
+ return;
696
+ return sendEventMessage(mappedEmitter);
697
+ });
698
+ if (autoConnect) {
699
+ connect();
700
+ }
701
+ socket.appManager.events.onOnline(() => {
702
+ if (autoConnect && !socket.adapter.connected) {
703
+ connect();
704
+ }
705
+ });
706
+ return {
707
+ connect,
708
+ reconnect,
709
+ disconnect,
710
+ listen,
711
+ emit
712
+ };
713
+ }
714
+ );
715
+
716
+ // src/socket/socket.ts
717
+ var Socket = class {
718
+ constructor(options) {
719
+ this.options = options;
720
+ __publicField(this, "emitter", new EventEmitter());
721
+ __publicField(this, "events", getSocketEvents(this.emitter));
722
+ __publicField(this, "url");
723
+ __publicField(this, "reconnectAttempts");
724
+ __publicField(this, "reconnectTime");
725
+ __publicField(this, "debug");
726
+ __publicField(this, "autoConnect");
727
+ // Callbacks
728
+ __publicField(this, "unstable_onConnectedCallbacks", []);
729
+ __publicField(this, "unstable_onDisconnectCallbacks", []);
730
+ __publicField(this, "unstable_onReconnectCallbacks", []);
731
+ __publicField(this, "unstable_onReconnectFailedCallbacks", []);
732
+ __publicField(this, "unstable_onMessageCallbacks", []);
733
+ __publicField(this, "unstable_onSendCallbacks", []);
734
+ __publicField(this, "unstable_onErrorCallbacks", []);
735
+ // Config
736
+ __publicField(this, "adapter");
737
+ __publicField(this, "loggerManager", new LoggerManager());
738
+ __publicField(this, "appManager", new AppManager());
739
+ // Logger
740
+ __publicField(this, "logger", this.loggerManager.initialize(this, "Socket"));
741
+ /**
742
+ * This method connects the socket to the server
743
+ */
744
+ __publicField(this, "connect", () => __async(this, null, function* () {
745
+ yield this.adapter.connect();
746
+ }));
747
+ /**
748
+ * This method disconnects the socket from the server
749
+ */
750
+ __publicField(this, "disconnect", () => __async(this, null, function* () {
751
+ yield this.adapter.disconnect();
752
+ }));
753
+ /**
754
+ * This method reconnect the socket to the server
755
+ */
756
+ __publicField(this, "reconnect", () => __async(this, null, function* () {
757
+ yield this.adapter.reconnect();
758
+ }));
759
+ __publicField(this, "setQueryParams", (queryParams) => {
760
+ this.adapter.setQueryParams(queryParams);
761
+ return this;
762
+ });
763
+ /**
764
+ * This method enables the logger usage and display the logs in console
765
+ */
766
+ __publicField(this, "setDebug", (enabled) => {
767
+ this.debug = enabled;
768
+ return this;
769
+ });
770
+ /**
771
+ * Set the logger severity of the messages displayed to the console
772
+ */
773
+ __publicField(this, "setLogLevel", (level) => {
774
+ this.loggerManager.setSeverity(level);
775
+ return this;
776
+ });
777
+ /**
778
+ * Set the new logger instance to the socket
779
+ */
780
+ __publicField(this, "setLogger", (callback) => {
781
+ this.loggerManager = callback(this);
782
+ return this;
783
+ });
784
+ /**
785
+ * ********************
786
+ * Interceptors
787
+ * ********************
788
+ */
789
+ __publicField(this, "unstable__modifySend", (emitter) => {
790
+ return interceptEmitter(this.unstable_onSendCallbacks, emitter);
791
+ });
792
+ __publicField(this, "unstable__modifyResponse", (data) => {
793
+ return interceptListener(this.unstable_onMessageCallbacks, data);
794
+ });
795
+ /**
796
+ * ********************
797
+ * Creators
798
+ * ********************
799
+ */
800
+ /**
801
+ * Create event listener
802
+ * @param options
803
+ * @returns
804
+ */
805
+ __publicField(this, "createListener", () => {
806
+ return (options) => {
807
+ return new Listener(this, options);
808
+ };
809
+ });
810
+ /**
811
+ * Create event emitter
812
+ * @param options
813
+ * @returns
814
+ */
815
+ __publicField(this, "createEmitter", () => {
816
+ return (options) => {
817
+ return new Emitter(this, options);
818
+ };
819
+ });
820
+ var _a;
821
+ const { url, adapter, reconnect, reconnectTime, queryParams } = this.options;
822
+ (_a = this.emitter) == null ? void 0 : _a.setMaxListeners(1e3);
823
+ this.url = url;
824
+ this.debug = false;
825
+ this.reconnectAttempts = reconnect != null ? reconnect : Infinity;
826
+ this.reconnectTime = reconnectTime != null ? reconnectTime : Time2.SEC * 5;
827
+ this.autoConnect = true;
828
+ const instanceOfAdapter = typeof adapter === "function" ? adapter() : adapter;
829
+ this.adapter = instanceOfAdapter || WebsocketAdapter();
830
+ if (queryParams) {
831
+ this.adapter.setQueryParams(queryParams);
832
+ }
833
+ this.adapter.initialize(this);
834
+ }
835
+ /**
836
+ * Callbacks
837
+ */
838
+ /**
839
+ * Triggered when connection is opened
840
+ * @param callback
841
+ * @returns
842
+ */
843
+ onConnected(callback) {
844
+ this.unstable_onConnectedCallbacks.push(callback);
845
+ return this;
846
+ }
847
+ /**
848
+ * Triggered when connection is closed
849
+ * @param callback
850
+ * @returns
851
+ */
852
+ onDisconnected(callback) {
853
+ this.unstable_onDisconnectCallbacks.push(callback);
854
+ return this;
855
+ }
856
+ /**
857
+ * Triggered when connection is getting reconnected
858
+ * @param callback
859
+ * @returns
860
+ */
861
+ onReconnect(callback) {
862
+ this.unstable_onReconnectCallbacks.push(callback);
863
+ return this;
864
+ }
865
+ /**
866
+ * Triggered when connection attempts are stopped
867
+ * @param callback
868
+ * @returns
869
+ */
870
+ onReconnectFailed(callback) {
871
+ this.unstable_onReconnectFailedCallbacks.push(callback);
872
+ return this;
873
+ }
874
+ /**
875
+ * Triggered when any message is received
876
+ * @param callback
877
+ * @returns
878
+ */
879
+ onMessage(callback) {
880
+ this.unstable_onMessageCallbacks.push(callback);
881
+ return this;
882
+ }
883
+ /**
884
+ * Triggered when any event is emitted
885
+ * @param callback
886
+ * @returns
887
+ */
888
+ onSend(callback) {
889
+ this.unstable_onSendCallbacks.push(callback);
890
+ return this;
891
+ }
892
+ /**
893
+ * Triggered when we receive error
894
+ * @param callback
895
+ * @returns
896
+ */
897
+ onError(callback) {
898
+ this.unstable_onErrorCallbacks.push(callback);
899
+ return this;
900
+ }
901
+ };
902
+
903
+ // src/socket/socket.utils.ts
904
+ var getErrorKey = () => "socket_error";
905
+ var getOpenKey = () => "socket_open";
906
+ var getCloseKey = () => "socket_close";
907
+ var getConnectingKey = () => "socket_connecting";
908
+ var getReconnectingKey = () => "socket_reconnecting";
909
+ var getReconnectingFailedKey = () => "socket_reconnecting_stop";
910
+ var getListenerEventKey = () => `listener_event`;
911
+ var getListenerRemoveKey = () => `listener_remove`;
912
+ var getEmitterStartEventKey = () => `emitter_start_event`;
913
+ var getEmitterErrorKey = () => `emitter_error`;
914
+ var getListenerRemoveByTopicKey = (event) => `${event}_listener_remove`;
915
+ var getListenerEventByTopicKey = (event) => `${event}_listener_event`;
916
+ var getEmitterStartEventByTopicKey = (event) => `${event}_emitter_start_event`;
917
+ var getEmitterErrorByTopicKey = (event) => `${event}_emitter_error`;
918
+ var interceptListener = (interceptors, event) => {
919
+ let newResponse = event;
920
+ for (const interceptor of interceptors) {
921
+ newResponse = interceptor({ event: event.data });
922
+ if (!newResponse)
923
+ throw new Error("Listener modifier must return data");
924
+ }
925
+ return newResponse;
926
+ };
927
+ var interceptEmitter = (interceptors, emitter) => {
928
+ let newEmitter = emitter;
929
+ for (const interceptor of interceptors) {
930
+ newEmitter = interceptor({ emitter });
931
+ if (!newEmitter)
932
+ throw new Error("Send modifier must return emitter");
933
+ }
934
+ return newEmitter;
935
+ };
936
+
937
+ // src/socket/socket.events.ts
938
+ var getSocketEvents = (eventEmitter) => ({
939
+ emitError: ({ error }) => {
940
+ eventEmitter.emit(getErrorKey(), { error });
941
+ },
942
+ emitConnected: () => {
943
+ eventEmitter.emit(getOpenKey());
944
+ },
945
+ emitDisconnected: () => {
946
+ eventEmitter.emit(getCloseKey());
947
+ },
948
+ emitConnecting: ({ connecting }) => {
949
+ eventEmitter.emit(getConnectingKey(), { connecting });
950
+ },
951
+ emitReconnecting: ({ attempts }) => {
952
+ eventEmitter.emit(getReconnectingKey(), { attempts });
953
+ },
954
+ emitReconnectingFailed: ({ attempts }) => {
955
+ eventEmitter.emit(getReconnectingFailedKey(), { attempts });
956
+ },
957
+ emitListenerEvent: ({
958
+ topic,
959
+ data,
960
+ extra
961
+ }) => {
962
+ eventEmitter.emit(getListenerEventKey(), { topic, data, extra });
963
+ eventEmitter.emit(getListenerEventByTopicKey(topic), { topic, data, extra });
964
+ },
965
+ emitListenerRemoveEvent: ({ topic }) => {
966
+ eventEmitter.emit(getListenerRemoveKey(), { topic });
967
+ eventEmitter.emit(getListenerRemoveByTopicKey(topic), { topic });
968
+ },
969
+ emitEmitterStartEvent: ({ emitter }) => {
970
+ eventEmitter.emit(getEmitterStartEventKey(), { emitter });
971
+ eventEmitter.emit(getEmitterStartEventByTopicKey(emitter.topic), { emitter });
972
+ },
973
+ emitEmitterError: ({
974
+ error,
975
+ emitter
976
+ }) => {
977
+ eventEmitter.emit(getEmitterErrorKey(), { error, emitter });
978
+ eventEmitter.emit(getEmitterErrorByTopicKey(emitter.topic), { error, emitter });
979
+ },
980
+ onError: (callback) => {
981
+ eventEmitter.on(getErrorKey(), callback);
982
+ return () => eventEmitter.removeListener(getErrorKey(), callback);
983
+ },
984
+ onConnected: (callback) => {
985
+ eventEmitter.on(getOpenKey(), callback);
986
+ return () => eventEmitter.removeListener(getOpenKey(), callback);
987
+ },
988
+ onDisconnected: (callback) => {
989
+ eventEmitter.on(getCloseKey(), callback);
990
+ return () => eventEmitter.removeListener(getCloseKey(), callback);
991
+ },
992
+ onConnecting: (callback) => {
993
+ eventEmitter.on(getConnectingKey(), callback);
994
+ return () => eventEmitter.removeListener(getConnectingKey(), callback);
995
+ },
996
+ onReconnecting: (callback) => {
997
+ eventEmitter.on(getReconnectingKey(), callback);
998
+ return () => eventEmitter.removeListener(getReconnectingKey(), callback);
999
+ },
1000
+ onReconnectingFailed: (callback) => {
1001
+ eventEmitter.on(getReconnectingFailedKey(), callback);
1002
+ return () => eventEmitter.removeListener(getReconnectingFailedKey(), callback);
1003
+ },
1004
+ // Emitters
1005
+ onEmitterStartEvent: (callback) => {
1006
+ eventEmitter.on(getEmitterStartEventKey(), callback);
1007
+ return () => eventEmitter.removeListener(getEmitterStartEventKey(), callback);
1008
+ },
1009
+ onEmitterStartEventByTopic: (emitter, callback) => {
1010
+ eventEmitter.on(getEmitterStartEventByTopicKey(emitter.topic), callback);
1011
+ return () => eventEmitter.removeListener(getEmitterStartEventByTopicKey(emitter.topic), callback);
1012
+ },
1013
+ onEmitterError: (callback) => {
1014
+ eventEmitter.on(getEmitterErrorKey(), callback);
1015
+ return () => eventEmitter.removeListener(getEmitterErrorKey(), callback);
1016
+ },
1017
+ onEmitterErrorByTopic: (emitter, callback) => {
1018
+ eventEmitter.on(getEmitterErrorByTopicKey(emitter.topic), callback);
1019
+ return () => eventEmitter.removeListener(getEmitterErrorByTopicKey(emitter.topic), callback);
1020
+ },
1021
+ // Listeners
1022
+ onListenerEvent: (callback) => {
1023
+ eventEmitter.on(getListenerEventKey(), callback);
1024
+ return () => eventEmitter.removeListener(getListenerEventKey(), callback);
1025
+ },
1026
+ onListenerEventByTopic: (listener, callback) => {
1027
+ eventEmitter.on(getListenerEventByTopicKey(listener.topic), callback);
1028
+ return () => eventEmitter.removeListener(getListenerEventByTopicKey(listener.topic), callback);
1029
+ },
1030
+ onListenerRemove: (callback) => {
1031
+ eventEmitter.on(getListenerRemoveKey(), callback);
1032
+ return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
1033
+ },
1034
+ onListenerRemoveByTopic: (listener, callback) => {
1035
+ eventEmitter.on(getListenerRemoveByTopicKey(listener.topic), callback);
1036
+ return () => eventEmitter.removeListener(getListenerRemoveByTopicKey(listener.topic), callback);
1037
+ }
1038
+ });
1039
+
1040
+ // src/adapter-sse/sse-adapter.ts
1041
+ import { stringifyQueryParams as stringifyQueryParams2 } from "@hyper-fetch/core";
1042
+
1043
+ // src/adapter-sse/sse-adapter.utils.ts
1044
+ var getServerSentEventsAdapter = (url, adapterOptions) => {
1045
+ try {
1046
+ if (!(window == null ? void 0 : window.EventSource))
1047
+ return null;
1048
+ } catch (error) {
1049
+ return null;
1050
+ }
1051
+ class HyperFetchEventSource extends EventSource {
1052
+ // eslint-disable-next-line @typescript-eslint/no-useless-constructor
1053
+ constructor(socketUrl, eventSourceInit) {
1054
+ super(socketUrl, eventSourceInit);
1055
+ __publicField(this, "listeners", /* @__PURE__ */ new Map());
1056
+ __publicField(this, "onopen", (...args) => {
1057
+ this.listeners.forEach(({ type, listener }) => {
1058
+ if (type === "open") {
1059
+ listener(...args);
1060
+ }
1061
+ });
1062
+ });
1063
+ __publicField(this, "onerror", (...args) => {
1064
+ this.listeners.forEach(({ type, listener }) => {
1065
+ if (type === "error") {
1066
+ listener(...args);
1067
+ }
1068
+ });
1069
+ });
1070
+ __publicField(this, "onmessage", (...args) => {
1071
+ this.listeners.forEach(({ type, listener }) => {
1072
+ if (type === "message") {
1073
+ listener(...args);
1074
+ }
1075
+ });
1076
+ });
1077
+ __publicField(this, "addEventListener", (type, listener, options) => {
1078
+ super.addEventListener(type, listener, options);
1079
+ this.listeners.set(listener, { type, listener, options });
1080
+ });
1081
+ __publicField(this, "removeEventListener", (type, listener, options) => {
1082
+ super.removeEventListener(type, listener, options);
1083
+ this.listeners.delete(listener);
1084
+ });
1085
+ __publicField(this, "clearListeners", () => {
1086
+ this.listeners.forEach(({ type, listener, options }) => {
1087
+ if (!(options == null ? void 0 : options.disableCleanup)) {
1088
+ this.removeEventListener(type, listener, options);
1089
+ }
1090
+ });
1091
+ });
1092
+ }
1093
+ }
1094
+ return new HyperFetchEventSource(url, adapterOptions == null ? void 0 : adapterOptions.eventSourceInit);
1095
+ };
1096
+
1097
+ // src/adapter-sse/sse-adapter.ts
1098
+ var ServerSentEventsAdapter = () => new SocketAdapter({
1099
+ name: "sse"
1100
+ }).setQueryParamsMapper(stringifyQueryParams2).setConnector(
1101
+ ({
1102
+ socket,
1103
+ adapter,
1104
+ getQueryParams,
1105
+ onConnect,
1106
+ onReconnect,
1107
+ onDisconnect,
1108
+ onListen,
1109
+ onConnected,
1110
+ onDisconnected,
1111
+ onError,
1112
+ onEvent
1113
+ }) => {
1114
+ var _a, _b;
1115
+ let sse;
1116
+ const autoConnect = typeof ((_a = socket.adapter.adapterOptions) == null ? void 0 : _a.autoConnect) === "boolean" ? (_b = socket.adapter.adapterOptions) == null ? void 0 : _b.autoConnect : true;
1117
+ const connect = () => {
1118
+ const url = getSocketUrl(socket.url, getQueryParams());
1119
+ const enabled = onConnect();
1120
+ if (!enabled) {
1121
+ return Promise.resolve(false);
1122
+ }
1123
+ sse == null ? void 0 : sse.clearListeners();
1124
+ sse == null ? void 0 : sse.close();
1125
+ const eventSource = getServerSentEventsAdapter(url, adapter.adapterOptions);
1126
+ sse = eventSource;
1127
+ if (!eventSource) {
1128
+ return Promise.resolve(false);
1129
+ }
1130
+ const timeout = setTimeout(() => {
1131
+ reconnect();
1132
+ }, socket.reconnectTime);
1133
+ eventSource.addEventListener("open", () => {
1134
+ clearTimeout(timeout);
1135
+ onConnected();
1136
+ });
1137
+ eventSource.addEventListener("error", (event) => {
1138
+ const error = getSocketError(event);
1139
+ onError({ error: new Error(error) });
1140
+ });
1141
+ eventSource.addEventListener("message", (newEvent) => {
1142
+ const { topic, data, event } = parseMessageEvent(newEvent);
1143
+ onEvent({ topic, data, extra: event });
1144
+ });
1145
+ return new Promise((resolve) => {
1146
+ if (eventSource.readyState === EventSource.OPEN) {
1147
+ resolve(true);
1148
+ adapter.setConnected(true);
1149
+ adapter.setConnecting(false);
1150
+ return;
1151
+ }
1152
+ const resolveConnected = () => {
1153
+ resolve(true);
1154
+ eventSource.removeEventListener("open", resolveConnected);
1155
+ };
1156
+ const resolveError = () => {
1157
+ resolve(false);
1158
+ eventSource.removeEventListener("error", resolveError);
1159
+ };
1160
+ eventSource.addEventListener("open", resolveConnected, { disableCleanup: true });
1161
+ eventSource.addEventListener("error", resolveError, { disableCleanup: true });
1162
+ });
1163
+ };
1164
+ const disconnect = () => __async(void 0, null, function* () {
1165
+ if (!sse) {
1166
+ adapter.setConnected(false);
1167
+ adapter.setConnecting(false);
1168
+ return Promise.resolve(true);
1169
+ }
1170
+ const currentSse = sse;
1171
+ const promise = new Promise((resolve) => {
1172
+ if (currentSse.readyState === EventSource.CLOSED) {
1173
+ resolve(true);
1174
+ adapter.setConnected(false);
1175
+ adapter.setConnecting(false);
1176
+ return;
1177
+ }
1178
+ const resolveDisconnected = () => {
1179
+ resolve(true);
1180
+ currentSse.removeEventListener("error", resolveDisconnected);
1181
+ };
1182
+ currentSse.addEventListener("error", resolveDisconnected, { disableCleanup: true });
1183
+ });
1184
+ onDisconnect();
1185
+ currentSse.close();
1186
+ onDisconnected();
1187
+ return promise;
1188
+ });
1189
+ const reconnect = () => {
1190
+ onReconnect({ disconnect, connect });
1191
+ };
1192
+ const listen = (listener, callback) => {
1193
+ return onListen({ listener, callback });
1194
+ };
1195
+ const emit = () => __async(void 0, null, function* () {
1196
+ throw new Error("Cannot emit events in SSE adapter");
1197
+ });
1198
+ if (autoConnect) {
1199
+ connect();
1200
+ }
1201
+ socket.appManager.events.onOnline(() => {
1202
+ if (autoConnect && !adapter.connected) {
1203
+ connect();
1204
+ }
1205
+ });
1206
+ return {
1207
+ connect,
1208
+ reconnect,
1209
+ disconnect,
1210
+ listen,
1211
+ emit
1212
+ };
1213
+ }
1214
+ );
1215
+ export {
1216
+ Emitter,
1217
+ Listener,
1218
+ ServerSentEventsAdapter,
1219
+ Socket,
1220
+ SocketAdapter,
1221
+ WebsocketAdapter,
1222
+ getAdapterBindings,
1223
+ getCloseKey,
1224
+ getConnectingKey,
1225
+ getEmitterErrorByTopicKey,
1226
+ getEmitterErrorKey,
1227
+ getEmitterStartEventByTopicKey,
1228
+ getEmitterStartEventKey,
1229
+ getErrorKey,
1230
+ getListenerEventByTopicKey,
1231
+ getListenerEventKey,
1232
+ getListenerRemoveByTopicKey,
1233
+ getListenerRemoveKey,
1234
+ getOpenKey,
1235
+ getReconnectingFailedKey,
1236
+ getReconnectingKey,
1237
+ getServerSentEventsAdapter,
1238
+ getSocketError,
1239
+ getSocketEvents,
1240
+ getSocketUrl,
1241
+ getWebsocketAdapter,
1242
+ interceptEmitter,
1243
+ interceptListener,
1244
+ parseMessageEvent
1245
+ };
1246
+ //# sourceMappingURL=index.js.map