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