@hyper-fetch/sockets 6.0.1 → 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.cjs.js DELETED
@@ -1,853 +0,0 @@
1
- var __create = Object.create;
2
- var __defProp = Object.defineProperty;
3
- var __defProps = Object.defineProperties;
4
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
- var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
6
- var __getOwnPropNames = Object.getOwnPropertyNames;
7
- var __getOwnPropSymbols = Object.getOwnPropertySymbols;
8
- var __getProtoOf = Object.getPrototypeOf;
9
- var __hasOwnProp = Object.prototype.hasOwnProperty;
10
- var __propIsEnum = Object.prototype.propertyIsEnumerable;
11
- var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
12
- var __spreadValues = (a, b) => {
13
- for (var prop in b || (b = {}))
14
- if (__hasOwnProp.call(b, prop))
15
- __defNormalProp(a, prop, b[prop]);
16
- if (__getOwnPropSymbols)
17
- for (var prop of __getOwnPropSymbols(b)) {
18
- if (__propIsEnum.call(b, prop))
19
- __defNormalProp(a, prop, b[prop]);
20
- }
21
- return a;
22
- };
23
- var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
24
- var __objRest = (source, exclude) => {
25
- var target = {};
26
- for (var prop in source)
27
- if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
28
- target[prop] = source[prop];
29
- if (source != null && __getOwnPropSymbols)
30
- for (var prop of __getOwnPropSymbols(source)) {
31
- if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
32
- target[prop] = source[prop];
33
- }
34
- return target;
35
- };
36
- var __export = (target, all) => {
37
- for (var name in all)
38
- __defProp(target, name, { get: all[name], enumerable: true });
39
- };
40
- var __copyProps = (to, from, except, desc) => {
41
- if (from && typeof from === "object" || typeof from === "function") {
42
- for (let key of __getOwnPropNames(from))
43
- if (!__hasOwnProp.call(to, key) && key !== except)
44
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
45
- }
46
- return to;
47
- };
48
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
49
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
50
- mod
51
- ));
52
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
53
- var __async = (__this, __arguments, generator) => {
54
- return new Promise((resolve, reject) => {
55
- var fulfilled = (value) => {
56
- try {
57
- step(generator.next(value));
58
- } catch (e) {
59
- reject(e);
60
- }
61
- };
62
- var rejected = (value) => {
63
- try {
64
- step(generator.throw(value));
65
- } catch (e) {
66
- reject(e);
67
- }
68
- };
69
- var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
70
- step((generator = generator.apply(__this, __arguments)).next());
71
- });
72
- };
73
-
74
- // src/index.ts
75
- var src_exports = {};
76
- __export(src_exports, {
77
- Emitter: () => Emitter,
78
- Listener: () => Listener,
79
- Socket: () => Socket,
80
- getCloseKey: () => getCloseKey,
81
- getConnectingKey: () => getConnectingKey,
82
- getEmitterEventByEndpointKey: () => getEmitterEventByEndpointKey,
83
- getEmitterEventKey: () => getEmitterEventKey,
84
- getErrorKey: () => getErrorKey,
85
- getListenerEventByEndpointKey: () => getListenerEventByEndpointKey,
86
- getListenerEventKey: () => getListenerEventKey,
87
- getListenerRemoveByEndpointKey: () => getListenerRemoveByEndpointKey,
88
- getListenerRemoveKey: () => getListenerRemoveKey,
89
- getOpenKey: () => getOpenKey,
90
- getReconnectingKey: () => getReconnectingKey,
91
- getReconnectingStopKey: () => getReconnectingStopKey,
92
- getSSEAdapter: () => getSSEAdapter,
93
- getSocketAdapterBindings: () => getSocketAdapterBindings,
94
- getSocketEvents: () => getSocketEvents,
95
- getSocketUrl: () => getSocketUrl,
96
- getWebsocketAdapter: () => getWebsocketAdapter,
97
- interceptEmitter: () => interceptEmitter,
98
- interceptListener: () => interceptListener,
99
- sseAdapter: () => sseAdapter,
100
- websocketAdapter: () => websocketAdapter
101
- });
102
- module.exports = __toCommonJS(src_exports);
103
-
104
- // src/socket/socket.ts
105
- var import_events = __toESM(require("events"));
106
- var import_core4 = require("@hyper-fetch/core");
107
-
108
- // src/listener/listener.ts
109
- var Listener = class {
110
- constructor(socket, listenerOptions) {
111
- this.socket = socket;
112
- this.listenerOptions = listenerOptions;
113
- this.connections = /* @__PURE__ */ new Set();
114
- this.paramsMapper = (params) => {
115
- let endpoint = this.listenerOptions.endpoint;
116
- if (params) {
117
- Object.entries(params).forEach(([key, value]) => {
118
- endpoint = endpoint.replace(new RegExp(`:${key}`, "g"), String(value));
119
- });
120
- }
121
- return endpoint;
122
- };
123
- this.listen = (_a) => {
124
- var _b = _a, { callback } = _b, options = __objRest(_b, ["callback"]);
125
- const instance = this.clone(options);
126
- const action = (response) => {
127
- this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
128
- return callback(response);
129
- };
130
- this.socket.adapter.listen(instance, action);
131
- const removeListener = () => {
132
- this.socket.adapter.removeListener(instance.endpoint, action);
133
- };
134
- return removeListener;
135
- };
136
- const { endpoint, options } = listenerOptions;
137
- this.endpoint = endpoint;
138
- this.options = options;
139
- }
140
- setOptions(options) {
141
- return this.clone({ options });
142
- }
143
- setParams(params) {
144
- return this.clone({ params });
145
- }
146
- onData(callback) {
147
- this.connections.add(callback);
148
- return this;
149
- }
150
- clone(options) {
151
- const newInstance = new Listener(this.socket, __spreadProps(__spreadValues(__spreadValues({}, this.listenerOptions), options), {
152
- endpoint: this.paramsMapper((options == null ? void 0 : options.params) || this.params)
153
- }));
154
- newInstance.connections = this.connections;
155
- return newInstance;
156
- }
157
- };
158
-
159
- // src/emitter/emitter.ts
160
- var import_core = require("@hyper-fetch/core");
161
- var Emitter = class {
162
- constructor(socket, emitterOptions, json, dataMapper) {
163
- this.socket = socket;
164
- this.emitterOptions = emitterOptions;
165
- this.dataMapper = dataMapper;
166
- this.data = null;
167
- this.connections = /* @__PURE__ */ new Set();
168
- this.setDataMapper = (mapper) => {
169
- return this.clone(void 0, mapper);
170
- };
171
- this.paramsMapper = (params) => {
172
- let endpoint = this.emitterOptions.endpoint;
173
- if (params) {
174
- Object.entries(params).forEach(([key, value]) => {
175
- endpoint = endpoint.replace(new RegExp(`:${key}`, "g"), String(value));
176
- });
177
- }
178
- return endpoint;
179
- };
180
- this.getAck = (ack) => {
181
- if (ack) {
182
- return (response) => {
183
- this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
184
- return ack(response);
185
- };
186
- }
187
- if (this.connections.size) {
188
- return (response) => {
189
- this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
190
- };
191
- }
192
- return void 0;
193
- };
194
- this.emit = ({
195
- data,
196
- params,
197
- options,
198
- ack
199
- } = {}) => {
200
- const instance = this.clone(__spreadProps(__spreadValues({}, options), { data, params }));
201
- const eventMessageId = (0, import_core.getUniqueRequestId)(instance.endpoint);
202
- this.socket.adapter.emit(eventMessageId, instance, instance.getAck(ack));
203
- return eventMessageId;
204
- };
205
- var _a, _b, _c;
206
- const { endpoint, timeout = import_core.DateInterval.second * 2, options } = emitterOptions;
207
- this.endpoint = (_a = json == null ? void 0 : json.endpoint) != null ? _a : endpoint;
208
- this.data = json == null ? void 0 : json.data;
209
- this.timeout = (_b = json == null ? void 0 : json.timeout) != null ? _b : timeout;
210
- this.options = (_c = json == null ? void 0 : json.options) != null ? _c : options;
211
- this.params = json == null ? void 0 : json.params;
212
- }
213
- setOptions(options) {
214
- return this.clone({ options });
215
- }
216
- setTimeout(timeout) {
217
- return this.clone({ timeout });
218
- }
219
- setData(data) {
220
- if (this.dataMapper) {
221
- return this.clone({ data: this.dataMapper(data) });
222
- }
223
- return this.clone({ data });
224
- }
225
- setParams(params) {
226
- return this.clone({ params });
227
- }
228
- onData(callback) {
229
- this.connections.add(callback);
230
- return this;
231
- }
232
- clone(options, mapper) {
233
- const json = __spreadProps(__spreadValues({
234
- timeout: this.timeout,
235
- options: this.options,
236
- data: this.data,
237
- params: (options == null ? void 0 : options.params) || this.params
238
- }, options), {
239
- endpoint: this.paramsMapper((options == null ? void 0 : options.params) || this.params)
240
- });
241
- const mapperFn = mapper || this.dataMapper;
242
- const newInstance = new Emitter(
243
- this.socket,
244
- this.emitterOptions,
245
- json,
246
- mapperFn
247
- );
248
- newInstance.connections = this.connections;
249
- return newInstance;
250
- }
251
- };
252
-
253
- // src/adapter/adapter.websocket.ts
254
- var import_core2 = require("@hyper-fetch/core");
255
- var websocketAdapter = (socket) => {
256
- const {
257
- open,
258
- listeners,
259
- connecting,
260
- reconnectionAttempts,
261
- removeListener,
262
- onConnect,
263
- onReconnect,
264
- onDisconnect,
265
- onListen,
266
- onEmit,
267
- onOpen,
268
- onClose,
269
- onError,
270
- onEvent
271
- } = getSocketAdapterBindings(socket);
272
- let pingTimer;
273
- let pongTimer;
274
- let adapter = getWebsocketAdapter(socket);
275
- const connect = () => {
276
- const enabled = onConnect();
277
- if (!enabled)
278
- return;
279
- adapter == null ? void 0 : adapter.close();
280
- adapter = getWebsocketAdapter(socket);
281
- if (!adapter)
282
- return;
283
- const timeout = setTimeout(() => {
284
- reconnect();
285
- }, socket.reconnectTime);
286
- adapter.onopen = () => {
287
- clearTimeout(timeout);
288
- onOpen();
289
- onHeartbeat();
290
- };
291
- adapter.onclose = () => {
292
- onClose();
293
- clearTimers();
294
- };
295
- adapter.onerror = (event) => {
296
- onError(new Error(event.type));
297
- };
298
- adapter.onmessage = (event) => {
299
- const extra = (0, import_core2.parseResponse)(event);
300
- extra.data = (0, import_core2.parseResponse)(extra.data);
301
- const eventListeners = listeners.get(extra.data.endpoint) || /* @__PURE__ */ new Map();
302
- eventListeners.forEach((_, action) => {
303
- action({ data: extra.data.data, extra });
304
- });
305
- onEvent(extra.data.endpoint, extra.data.data, extra);
306
- onHeartbeat();
307
- };
308
- };
309
- const disconnect = () => {
310
- onDisconnect();
311
- adapter.close();
312
- clearTimers();
313
- };
314
- const reconnect = () => {
315
- onReconnect(disconnect, connect);
316
- };
317
- const clearTimers = () => {
318
- clearTimeout(pingTimer);
319
- clearTimeout(pongTimer);
320
- };
321
- const sendEventMessage = (payload) => {
322
- adapter.send(JSON.stringify({ id: payload.id, endpoint: payload.endpoint, data: payload.data }));
323
- };
324
- const onHeartbeat = () => {
325
- const options = socket.options.adapterOptions || {};
326
- const {
327
- heartbeat = false,
328
- pingTimeout = import_core2.DateInterval.second * 5,
329
- pongTimeout = import_core2.DateInterval.second * 5,
330
- heartbeatMessage = "heartbeat"
331
- } = options;
332
- if (connecting || !heartbeat)
333
- return;
334
- clearTimers();
335
- pingTimer = setTimeout(() => {
336
- const id = "heartbeat";
337
- sendEventMessage({ id, data: heartbeatMessage, endpoint: "heartbeat" });
338
- pongTimer = setTimeout(() => {
339
- adapter.close();
340
- }, pongTimeout);
341
- }, pingTimeout);
342
- };
343
- const listen = (listener, callback) => {
344
- return onListen(listener, callback);
345
- };
346
- const emit = (eventMessageId, emitter, ack) => __async(void 0, null, function* () {
347
- const enabled = onEmit(emitter);
348
- if (!enabled)
349
- return;
350
- if (ack || emitter.connections.size) {
351
- let timeout;
352
- const unmount = onListen(emitter, (response) => {
353
- if (response.extra.data.id === eventMessageId) {
354
- ack(__spreadProps(__spreadValues({}, response), { error: null }));
355
- clearTimeout(timeout);
356
- unmount();
357
- }
358
- });
359
- timeout = setTimeout(() => {
360
- unmount();
361
- ack({ error: new Error("Server did not acknowledge the event"), data: null, extra: null });
362
- }, emitter.timeout);
363
- }
364
- const emitterInstance = yield socket.__modifySend(emitter);
365
- sendEventMessage({ id: eventMessageId, data: emitterInstance.data, endpoint: emitterInstance.endpoint });
366
- socket.events.emitEmitterEvent(emitterInstance);
367
- });
368
- if (socket.autoConnect) {
369
- connect();
370
- }
371
- socket.appManager.events.onOnline(() => {
372
- if (socket.autoConnect && !open) {
373
- connect();
374
- }
375
- });
376
- return {
377
- open,
378
- listeners,
379
- reconnectionAttempts,
380
- connecting,
381
- listen,
382
- removeListener,
383
- emit,
384
- connect,
385
- reconnect,
386
- disconnect
387
- };
388
- };
389
-
390
- // src/adapter/adapter.sse.ts
391
- var import_core3 = require("@hyper-fetch/core");
392
- var sseAdapter = (socket) => {
393
- const {
394
- open,
395
- reconnectionAttempts,
396
- listeners,
397
- connecting,
398
- removeListener,
399
- onConnect,
400
- onReconnect,
401
- onDisconnect,
402
- onListen,
403
- onOpen,
404
- onError,
405
- onEvent,
406
- onClose
407
- } = getSocketAdapterBindings(socket);
408
- let pingTimer;
409
- let pongTimer;
410
- let adapter = getSSEAdapter(socket);
411
- const connect = () => {
412
- const enabled = onConnect();
413
- if (!enabled)
414
- return;
415
- adapter == null ? void 0 : adapter.close();
416
- adapter = getSSEAdapter(socket);
417
- if (!adapter)
418
- return;
419
- const timeout = setTimeout(() => {
420
- reconnect();
421
- }, socket.reconnectTime);
422
- adapter.onopen = () => {
423
- clearTimeout(timeout);
424
- onOpen();
425
- };
426
- adapter.onerror = (event) => {
427
- onError(new Error(event.type));
428
- };
429
- adapter.onmessage = (event) => {
430
- const extra = (0, import_core3.parseResponse)(event);
431
- const response = (0, import_core3.parseResponse)(event.data);
432
- const data = (0, import_core3.parseResponse)(response.data);
433
- const eventListeners = listeners.get(response.endpoint) || /* @__PURE__ */ new Map();
434
- eventListeners.forEach((_, action) => {
435
- action({ data, extra: response });
436
- });
437
- onEvent(response.endpoint, data, extra);
438
- };
439
- };
440
- const disconnect = () => {
441
- onDisconnect();
442
- adapter.close();
443
- onClose();
444
- clearTimers();
445
- };
446
- const reconnect = () => {
447
- onReconnect(disconnect, connect);
448
- };
449
- const clearTimers = () => {
450
- clearTimeout(pingTimer);
451
- clearTimeout(pongTimer);
452
- };
453
- const listen = (listener, callback) => {
454
- return onListen(listener, callback);
455
- };
456
- const emit = () => __async(void 0, null, function* () {
457
- throw new Error("Cannot emit events in SSE mode");
458
- });
459
- if (socket.autoConnect) {
460
- connect();
461
- }
462
- socket.appManager.events.onOnline(() => {
463
- if (socket.autoConnect && !open) {
464
- connect();
465
- }
466
- });
467
- return {
468
- open,
469
- reconnectionAttempts,
470
- listeners,
471
- connecting,
472
- listen,
473
- removeListener,
474
- emit,
475
- connect,
476
- reconnect,
477
- disconnect
478
- };
479
- };
480
-
481
- // src/adapter/adapter.utils.ts
482
- var getSocketUrl = (socket) => {
483
- const queryParams = socket.queryParamsStringify(socket.queryParams).substring(1);
484
- const authParams = socket.queryParamsStringify(socket.auth).substring(1);
485
- const connector = queryParams && authParams ? "&" : "";
486
- const queryPrefix = authParams || queryParams ? "?" : "";
487
- const fullUrl = `${socket.url}${queryPrefix}${authParams}${connector}${queryParams}`;
488
- return fullUrl;
489
- };
490
- var getWebsocketAdapter = (socket) => {
491
- var _a;
492
- if (!(window == null ? void 0 : window.WebSocket))
493
- return null;
494
- return new WebSocket(getSocketUrl(socket), (_a = socket.options.adapterOptions) == null ? void 0 : _a.protocols);
495
- };
496
- var getSSEAdapter = (socket) => {
497
- var _a;
498
- if (!(window == null ? void 0 : window.EventSource))
499
- return null;
500
- return new EventSource(getSocketUrl(socket), (_a = socket.options.adapterOptions) == null ? void 0 : _a.protocols);
501
- };
502
-
503
- // src/adapter/adapter.bindings.ts
504
- var getSocketAdapterBindings = (socket, defaults) => {
505
- var _a, _b, _c, _d;
506
- const logger = socket.loggerManager.init("Socket Adapter");
507
- const listeners = /* @__PURE__ */ new Map();
508
- let open = (_a = defaults == null ? void 0 : defaults.open) != null ? _a : false;
509
- let connecting = (_b = defaults == null ? void 0 : defaults.connecting) != null ? _b : false;
510
- let forceClosed = (_c = defaults == null ? void 0 : defaults.forceClosed) != null ? _c : false;
511
- let reconnectionAttempts = (_d = defaults == null ? void 0 : defaults.reconnectionAttempts) != null ? _d : 0;
512
- const onConnect = () => {
513
- if (!socket.appManager.isOnline || connecting) {
514
- logger.warning("Cannot initialize adapter.", {
515
- connecting,
516
- online: socket.appManager.isOnline
517
- });
518
- return false;
519
- }
520
- forceClosed = false;
521
- connecting = true;
522
- reconnectionAttempts = 0;
523
- socket.events.emitConnecting();
524
- return true;
525
- };
526
- const onDisconnect = () => {
527
- logger.debug("Disconnecting", { reconnectionAttempts });
528
- open = false;
529
- connecting = false;
530
- forceClosed = true;
531
- reconnectionAttempts = 0;
532
- return true;
533
- };
534
- const onReconnect = (disconnect, connect) => {
535
- disconnect();
536
- if (reconnectionAttempts < socket.reconnect) {
537
- reconnectionAttempts += 1;
538
- logger.debug("Reconnecting", { reconnectionAttempts });
539
- connect();
540
- socket.__onReconnectCallbacks.forEach((callback) => {
541
- callback(socket);
542
- });
543
- socket.events.emitReconnecting(reconnectionAttempts);
544
- return true;
545
- }
546
- logger.debug("Stopped reconnecting", { reconnectionAttempts });
547
- socket.__onReconnectStopCallbacks.forEach((callback) => {
548
- callback(socket);
549
- });
550
- socket.events.emitReconnectingStop(reconnectionAttempts);
551
- return false;
552
- };
553
- const removeListener = (endpoint, callback) => {
554
- const listenerGroup = listeners.get(endpoint);
555
- if (listenerGroup) {
556
- const unmount = listenerGroup.get(callback);
557
- logger.debug("Removed event listener", { endpoint });
558
- socket.events.emitListenerRemoveEvent(endpoint);
559
- listenerGroup.delete(callback);
560
- unmount == null ? void 0 : unmount();
561
- return true;
562
- }
563
- return false;
564
- };
565
- const onListen = (listener, callback, unmount = () => null) => {
566
- const listenerGroup = listeners.get(listener.endpoint) || listeners.set(listener.endpoint, /* @__PURE__ */ new Map()).get(listener.endpoint);
567
- listenerGroup.set(callback, unmount);
568
- return () => removeListener(listener.endpoint, callback);
569
- };
570
- const onEmit = (emitter) => {
571
- if (connecting || !open) {
572
- logger.error("Cannot emit event when connection is not open");
573
- return false;
574
- }
575
- socket.events.emitEmitterEvent(emitter);
576
- return true;
577
- };
578
- const onOpen = () => {
579
- logger.info("Connection open");
580
- socket.__onOpenCallbacks.forEach((callback) => {
581
- callback(socket);
582
- });
583
- open = true;
584
- connecting = false;
585
- socket.events.emitOpen();
586
- };
587
- const onClose = () => {
588
- logger.info("Connection closed");
589
- socket.__onCloseCallbacks.forEach((callback) => {
590
- callback(socket);
591
- });
592
- open = false;
593
- connecting = false;
594
- socket.events.emitClose();
595
- };
596
- const onError = (event) => {
597
- logger.info("Error message", { event });
598
- socket.__onErrorCallbacks.forEach((callback) => {
599
- callback(event, socket);
600
- });
601
- socket.events.emitError(event);
602
- };
603
- const onEvent = (endpoint, response, resposeExtra) => {
604
- logger.info("New event message", { response, resposeExtra });
605
- const { data, extra } = socket.__modifyResponse({ data: response, extra: resposeExtra });
606
- socket.events.emitListenerEvent(endpoint, { data, extra });
607
- };
608
- return {
609
- open,
610
- connecting,
611
- reconnectionAttempts,
612
- forceClosed,
613
- onConnect,
614
- onReconnect,
615
- onDisconnect,
616
- onListen,
617
- onEmit,
618
- onOpen,
619
- onClose,
620
- onError,
621
- onEvent,
622
- listeners,
623
- removeListener
624
- };
625
- };
626
-
627
- // src/socket/socket.ts
628
- var Socket = class {
629
- constructor(options) {
630
- this.options = options;
631
- this.emitter = new import_events.default();
632
- this.events = getSocketEvents(this.emitter);
633
- this.__onOpenCallbacks = [];
634
- this.__onCloseCallbacks = [];
635
- this.__onReconnectCallbacks = [];
636
- this.__onReconnectStopCallbacks = [];
637
- this.__onMessageCallbacks = [];
638
- this.__onSendCallbacks = [];
639
- this.__onErrorCallbacks = [];
640
- this.loggerManager = new import_core4.LoggerManager(this);
641
- this.appManager = new import_core4.AppManager();
642
- this.logger = this.loggerManager.init("Socket");
643
- this.queryParamsStringify = (queryParams) => {
644
- return (0, import_core4.stringifyQueryParams)(queryParams, this.queryParamsConfig);
645
- };
646
- this.setDebug = (debug) => {
647
- this.debug = debug;
648
- return this;
649
- };
650
- this.setLoggerSeverity = (severity) => {
651
- this.loggerManager.setSeverity(severity);
652
- return this;
653
- };
654
- this.setLogger = (callback) => {
655
- this.loggerManager = callback(this);
656
- return this;
657
- };
658
- this.setAuth = (auth) => {
659
- this.auth = auth;
660
- this.adapter.reconnect();
661
- return this;
662
- };
663
- this.setQuery = (queryParams) => {
664
- this.queryParams = queryParams;
665
- this.adapter.reconnect();
666
- return this;
667
- };
668
- this.__modifySend = (emitter) => {
669
- return interceptEmitter(this.__onSendCallbacks, emitter);
670
- };
671
- this.__modifyResponse = (data) => {
672
- return interceptListener(this.__onMessageCallbacks, data, this);
673
- };
674
- this.createListener = () => {
675
- return (options) => {
676
- return new Listener(this, options);
677
- };
678
- };
679
- this.createEmitter = () => {
680
- return (options) => {
681
- return new Emitter(this, options);
682
- };
683
- };
684
- const {
685
- url,
686
- auth,
687
- adapter,
688
- queryParams,
689
- autoConnect,
690
- reconnect,
691
- reconnectTime,
692
- queryParamsConfig,
693
- queryParamsStringify
694
- } = this.options;
695
- this.url = url;
696
- this.auth = auth;
697
- this.queryParams = queryParams;
698
- this.debug = false;
699
- this.autoConnect = autoConnect != null ? autoConnect : true;
700
- this.reconnect = reconnect != null ? reconnect : Infinity;
701
- this.reconnectTime = reconnectTime != null ? reconnectTime : import_core4.DateInterval.second * 2;
702
- if (queryParamsConfig) {
703
- this.queryParamsConfig = queryParamsConfig;
704
- }
705
- if (queryParamsStringify) {
706
- this.queryParamsStringify = queryParamsStringify;
707
- }
708
- this.adapter = adapter ? adapter(this) : websocketAdapter(this);
709
- }
710
- onOpen(callback) {
711
- this.__onOpenCallbacks.push(callback);
712
- return this;
713
- }
714
- onClose(callback) {
715
- this.__onCloseCallbacks.push(callback);
716
- return this;
717
- }
718
- onReconnect(callback) {
719
- this.__onReconnectCallbacks.push(callback);
720
- return this;
721
- }
722
- onReconnectStop(callback) {
723
- this.__onReconnectStopCallbacks.push(callback);
724
- return this;
725
- }
726
- onMessage(callback) {
727
- this.__onMessageCallbacks.push(callback);
728
- return this;
729
- }
730
- onSend(callback) {
731
- this.__onSendCallbacks.push(callback);
732
- return this;
733
- }
734
- onError(callback) {
735
- this.__onErrorCallbacks.push(callback);
736
- return this;
737
- }
738
- };
739
-
740
- // src/socket/socket.utils.ts
741
- var getErrorKey = () => "socket_error";
742
- var getOpenKey = () => "socket_open";
743
- var getCloseKey = () => "socket_close";
744
- var getConnectingKey = () => "socket_connecting";
745
- var getReconnectingKey = () => "socket_reconnecting";
746
- var getReconnectingStopKey = () => "socket_reconnecting_stop";
747
- var getListenerEventKey = () => `listener_event`;
748
- var getListenerRemoveKey = () => `listener_remove`;
749
- var getEmitterEventKey = () => `emitter_event`;
750
- var getListenerRemoveByEndpointKey = (event) => `${event}_listener_remove`;
751
- var getListenerEventByEndpointKey = (event) => `${event}_listener_event`;
752
- var getEmitterEventByEndpointKey = (event) => `${event}_emitter_event`;
753
- var interceptListener = (interceptors, data, socket) => {
754
- let newResponse = data;
755
- for (const interceptor of interceptors) {
756
- newResponse = interceptor(data, socket);
757
- if (!newResponse)
758
- throw new Error("Listener modifier must return data");
759
- }
760
- return newResponse;
761
- };
762
- var interceptEmitter = (interceptors, emitter) => {
763
- let newEmitter = emitter;
764
- for (const interceptor of interceptors) {
765
- newEmitter = interceptor(emitter);
766
- if (!newEmitter)
767
- throw new Error("Send modifier must return emitter");
768
- }
769
- return newEmitter;
770
- };
771
-
772
- // src/socket/socket.events.ts
773
- var getSocketEvents = (eventEmitter) => ({
774
- emitError: (event) => {
775
- eventEmitter.emit(getErrorKey(), event);
776
- },
777
- emitOpen: () => {
778
- eventEmitter.emit(getOpenKey());
779
- },
780
- emitClose: () => {
781
- eventEmitter.emit(getCloseKey());
782
- },
783
- emitConnecting: () => {
784
- eventEmitter.emit(getConnectingKey());
785
- },
786
- emitReconnecting: (attempts) => {
787
- eventEmitter.emit(getReconnectingKey(), attempts);
788
- },
789
- emitReconnectingStop: (attempts) => {
790
- eventEmitter.emit(getReconnectingStopKey(), attempts);
791
- },
792
- emitListenerEvent: (endpoint, { data, extra }) => {
793
- eventEmitter.emit(getListenerEventKey(), { endpoint, data, extra });
794
- eventEmitter.emit(getListenerEventByEndpointKey(endpoint), { endpoint, data, extra });
795
- },
796
- emitListenerRemoveEvent: (endpoint) => {
797
- eventEmitter.emit(getListenerRemoveKey(), endpoint);
798
- eventEmitter.emit(getListenerRemoveByEndpointKey(endpoint));
799
- },
800
- emitEmitterEvent: (emitter) => {
801
- eventEmitter.emit(getEmitterEventKey(), emitter);
802
- eventEmitter.emit(getEmitterEventByEndpointKey(emitter.endpoint), emitter);
803
- },
804
- onError: (callback) => {
805
- eventEmitter.on(getErrorKey(), callback);
806
- return () => eventEmitter.removeListener(getErrorKey(), callback);
807
- },
808
- onOpen: (callback) => {
809
- eventEmitter.on(getOpenKey(), callback);
810
- return () => eventEmitter.removeListener(getOpenKey(), callback);
811
- },
812
- onClose: (callback) => {
813
- eventEmitter.on(getCloseKey(), callback);
814
- return () => eventEmitter.removeListener(getCloseKey(), callback);
815
- },
816
- onConnecting: (callback) => {
817
- eventEmitter.on(getConnectingKey(), callback);
818
- return () => eventEmitter.removeListener(getConnectingKey(), callback);
819
- },
820
- onReconnecting: (callback) => {
821
- eventEmitter.on(getReconnectingKey(), callback);
822
- return () => eventEmitter.removeListener(getReconnectingKey(), callback);
823
- },
824
- onReconnectingStop: (callback) => {
825
- eventEmitter.on(getReconnectingStopKey(), callback);
826
- return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
827
- },
828
- onListenerEvent: (callback) => {
829
- eventEmitter.on(getListenerEventKey(), callback);
830
- return () => eventEmitter.removeListener(getListenerEventKey(), callback);
831
- },
832
- onEmitterEvent: (callback) => {
833
- eventEmitter.on(getEmitterEventKey(), callback);
834
- return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
835
- },
836
- onListenerEventByEndpoint: (listener, callback) => {
837
- eventEmitter.on(getListenerEventByEndpointKey(listener.endpoint), callback);
838
- return () => eventEmitter.removeListener(getListenerEventByEndpointKey(listener.endpoint), callback);
839
- },
840
- onListenerRemove: (callback) => {
841
- eventEmitter.on(getListenerRemoveKey(), callback);
842
- return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
843
- },
844
- onListenerRemoveByEndpoint: (listener, callback) => {
845
- eventEmitter.on(getListenerRemoveByEndpointKey(listener.endpoint), callback);
846
- return () => eventEmitter.removeListener(getListenerRemoveByEndpointKey(listener.endpoint), callback);
847
- },
848
- onEmitterEventByEndpoint: (emitter, callback) => {
849
- eventEmitter.on(getEmitterEventByEndpointKey(emitter.endpoint), callback);
850
- return () => eventEmitter.removeListener(getEmitterEventByEndpointKey(emitter.endpoint), callback);
851
- }
852
- });
853
- //# sourceMappingURL=index.cjs.js.map