@hyper-fetch/sockets 8.2.0 → 8.2.3

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 (83) hide show
  1. package/README.md +3 -1
  2. package/__tests__/e2e/e2e.connection.spec.ts +1 -1
  3. package/__tests__/e2e/e2e.edge-cases.spec.ts +1 -1
  4. package/__tests__/e2e/e2e.emitters.spec.ts +1 -1
  5. package/__tests__/e2e/e2e.heartbeat.spec.ts +4 -4
  6. package/__tests__/features/adapter/adapter.base.spec.ts +1 -0
  7. package/__tests__/features/adapter/adapter.bindings.spec.ts +2 -1
  8. package/__tests__/features/adapter/adapter.connection.spec.ts +2 -2
  9. package/__tests__/features/adapter/adapter.error.spec.ts +1 -1
  10. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +2 -2
  11. package/__tests__/features/adapter/adapter.sse.spec.ts +6 -6
  12. package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +1 -1
  13. package/__tests__/features/adapter/adapter.websocket.spec.ts +5 -5
  14. package/__tests__/features/listener/listener.listen.spec.ts +1 -1
  15. package/__tests__/features/listener/listener.sse.spec.ts +2 -2
  16. package/__tests__/features/listener/listener.typescript.spec.ts +0 -1
  17. package/__tests__/features/sdk/sdk.base.spec.ts +4 -3
  18. package/__tests__/features/sdk/sdk.configuration.spec.ts +3 -2
  19. package/__tests__/features/sdk/sdk.types.spec.ts +4 -4
  20. package/__tests__/features/socket/socket.base.spec.ts +4 -4
  21. package/__tests__/features/socket/socket.callbacks.spec.ts +1 -1
  22. package/__tests__/features/socket/socket.methods.spec.ts +1 -2
  23. package/__tests__/features/socket/socket.misc.spec.ts +3 -3
  24. package/__tests__/features/socket/socket.utils.spec.ts +0 -1
  25. package/__tests__/tsconfig.json +4 -17
  26. package/__tests__/utils/client.utils.ts +1 -1
  27. package/__tests__/utils/emitter.utils.ts +1 -2
  28. package/__tests__/utils/listener.utils.ts +2 -3
  29. package/__tests__/utils/socket.utils.ts +2 -2
  30. package/dist/adapter/adapter.bindings.d.ts +3 -3
  31. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  32. package/dist/adapter/adapter.d.ts +4 -4
  33. package/dist/adapter/adapter.d.ts.map +1 -1
  34. package/dist/adapter/adapter.types.d.ts.map +1 -1
  35. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  36. package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -1
  37. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  38. package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -1
  39. package/dist/emitter/emitter.d.ts +1 -1
  40. package/dist/emitter/emitter.d.ts.map +1 -1
  41. package/dist/emitter/emitter.types.d.ts.map +1 -1
  42. package/dist/index.mjs +862 -862
  43. package/dist/index.mjs.map +1 -1
  44. package/dist/listener/listener.d.ts +1 -1
  45. package/dist/listener/listener.d.ts.map +1 -1
  46. package/dist/listener/listener.types.d.ts.map +1 -1
  47. package/dist/sdk/sdk.d.ts +2 -2
  48. package/dist/sdk/sdk.d.ts.map +1 -1
  49. package/dist/socket/socket.create.d.ts +1 -1
  50. package/dist/socket/socket.create.d.ts.map +1 -1
  51. package/dist/socket/socket.d.ts +5 -5
  52. package/dist/socket/socket.d.ts.map +1 -1
  53. package/dist/socket/socket.events.d.ts +2 -2
  54. package/dist/socket/socket.events.d.ts.map +1 -1
  55. package/dist/socket/socket.types.d.ts +1 -1
  56. package/dist/socket/socket.types.d.ts.map +1 -1
  57. package/dist/socket/socket.utils.d.ts.map +1 -1
  58. package/dist/types/tuple.types.d.ts +1 -1
  59. package/dist/types/tuple.types.d.ts.map +1 -1
  60. package/dist/utils/socket.errors.d.ts.map +1 -1
  61. package/package.json +8 -8
  62. package/src/adapter/adapter.bindings.ts +3 -3
  63. package/src/adapter/adapter.ts +8 -8
  64. package/src/adapter/adapter.types.ts +1 -0
  65. package/src/adapter-sse/sse-adapter.ts +7 -7
  66. package/src/adapter-sse/sse-adapter.utils.ts +4 -4
  67. package/src/adapter-websockets/websocket-adapter.ts +11 -11
  68. package/src/adapter-websockets/websocket-adapter.utils.ts +4 -4
  69. package/src/emitter/emitter.ts +5 -6
  70. package/src/emitter/emitter.types.ts +0 -1
  71. package/src/listener/listener.ts +4 -5
  72. package/src/listener/listener.types.ts +0 -1
  73. package/src/sdk/sdk.ts +9 -9
  74. package/src/socket/socket.create.ts +1 -1
  75. package/src/socket/socket.events.ts +3 -4
  76. package/src/socket/socket.ts +8 -9
  77. package/src/socket/socket.types.ts +1 -1
  78. package/src/socket/socket.utils.ts +3 -2
  79. package/src/types/tuple.types.ts +1 -1
  80. package/src/utils/socket.errors.ts +26 -13
  81. package/tsconfig.json +20 -2
  82. package/vite.config.ts +30 -21
  83. package/.eslintrc.cjs +0 -12
package/dist/index.mjs CHANGED
@@ -22,952 +22,952 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
22
22
  enumerable: true
23
23
  }) : target, mod));
24
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;
25
+ //#region src/adapter/adapter.bindings.ts
26
+ var getAdapterBindings = (socket) => {
27
+ const { adapter } = socket;
28
+ const logger = socket.loggerManager.initialize(socket, "Socket Bindings");
29
+ const onConnect = () => {
30
+ if (!socket.appManager.isOnline || adapter.connecting) {
31
+ logger.warning({
32
+ title: "Cannot initialize adapter.",
33
+ type: "system",
34
+ extra: {
35
+ connecting: adapter.connecting,
36
+ online: socket.appManager.isOnline
37
+ }
38
+ });
39
+ return false;
72
40
  }
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);
41
+ socket.adapter.setForceClosed(false);
42
+ socket.adapter.setConnecting(true);
43
+ socket.adapter.setReconnectionAttempts(0);
44
+ socket.events.emitConnecting({ connecting: true });
45
+ return true;
86
46
  };
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
- }
47
+ const onDisconnect = () => {
48
+ logger.debug({
49
+ title: "Disconnecting",
50
+ type: "system",
51
+ extra: { reconnectionAttempts: adapter.reconnectionAttempts }
52
+ });
53
+ socket.adapter.setConnected(false);
54
+ socket.adapter.setConnecting(false);
55
+ socket.adapter.setForceClosed(true);
56
+ socket.adapter.setReconnectionAttempts(0);
110
57
  return true;
111
58
  };
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
- }
59
+ const onReconnect = async ({ disconnect, connect }) => {
60
+ const currentAttempts = adapter.reconnectionAttempts;
61
+ socket.unstable_onReconnectCallbacks.forEach((callback) => {
62
+ callback();
63
+ });
64
+ socket.events.emitReconnecting({ attempts: currentAttempts });
65
+ await disconnect();
66
+ if (currentAttempts < socket.reconnectAttempts) {
67
+ const nextAttempts = currentAttempts + 1;
68
+ socket.adapter.setReconnectionAttempts(nextAttempts);
69
+ logger.debug({
70
+ title: "Reconnecting",
71
+ type: "system",
72
+ extra: { reconnectionAttempts: nextAttempts }
73
+ });
74
+ await connect();
75
+ if (!adapter.connected) socket.adapter.setReconnectionAttempts(nextAttempts);
76
+ return true;
145
77
  }
146
- return target;
147
- }
148
- EventEmitter.prototype.addListener = function addListener(type, listener) {
149
- return _addListener(this, type, listener, false);
78
+ logger.error({
79
+ title: "Stopped reconnecting",
80
+ type: "system",
81
+ extra: { reconnectionAttempts: currentAttempts }
82
+ });
83
+ socket.unstable_onReconnectFailedCallbacks.forEach((callback) => {
84
+ callback();
85
+ });
86
+ socket.events.emitReconnectingFailed({ attempts: currentAttempts });
87
+ return false;
150
88
  };
151
- EventEmitter.prototype.on = EventEmitter.prototype.addListener;
152
- EventEmitter.prototype.prependListener = function prependListener(type, listener) {
153
- return _addListener(this, type, listener, true);
89
+ const onListen = ({ listener, callback, onUnmount = () => null }) => {
90
+ (adapter.listeners.get(listener.topic) || adapter.listeners.set(listener.topic, /* @__PURE__ */ new Map()).get(listener.topic)).set(callback, onUnmount);
91
+ return () => socket.adapter.removeListener({
92
+ topic: listener.topic,
93
+ callback
94
+ });
154
95
  };
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);
96
+ const onEmit = async ({ emitter }) => {
97
+ if (adapter.connecting || !adapter.connected) {
98
+ logger.error({
99
+ title: "Cannot emit event when connection is not open",
100
+ type: "system",
101
+ extra: {}
102
+ });
103
+ return null;
161
104
  }
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;
105
+ emitter.payload = emitter.unstable_payloadMapper ? emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
106
+ const emitterInstance = await socket.unstable__modifySend(emitter);
107
+ socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
108
+ return emitterInstance;
185
109
  };
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;
110
+ const onEmitError = ({ emitter, error }) => {
111
+ socket.events.emitEmitterError({
112
+ error,
113
+ emitter
114
+ });
212
115
  };
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;
116
+ const onConnected = () => {
117
+ logger.info({
118
+ title: "Connection open",
119
+ type: "system",
120
+ extra: {}
121
+ });
122
+ adapter.setConnected(true);
123
+ adapter.setConnecting(false);
124
+ adapter.setReconnectionAttempts(0);
125
+ socket.events.emitConnecting({ connecting: false });
126
+ socket.events.emitConnected();
127
+ socket.unstable_onConnectedCallbacks.forEach((callback) => {
128
+ callback();
129
+ });
242
130
  };
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);
131
+ const onDisconnected = () => {
132
+ logger.info({
133
+ title: "Connection closed",
134
+ type: "system",
135
+ extra: {}
136
+ });
137
+ adapter.setConnected(false);
138
+ adapter.setConnecting(false);
139
+ socket.events.emitConnecting({ connecting: false });
140
+ socket.events.emitDisconnected();
141
+ socket.unstable_onDisconnectCallbacks.forEach((callback) => {
142
+ callback();
143
+ });
253
144
  };
254
- EventEmitter.prototype.rawListeners = function rawListeners(type) {
255
- return _listeners(this, type, false);
145
+ const onError = ({ error }) => {
146
+ logger.info({
147
+ title: "Error message",
148
+ type: "system",
149
+ extra: { error }
150
+ });
151
+ socket.unstable_onErrorCallbacks.forEach((callback) => {
152
+ callback({ error });
153
+ });
154
+ socket.events.emitError({ error });
256
155
  };
257
- EventEmitter.listenerCount = function(emitter, type) {
258
- if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type);
259
- else return listenerCount.call(emitter, type);
156
+ const onEvent = ({ topic, data, extra }) => {
157
+ logger.info({
158
+ title: "New event message",
159
+ type: "system",
160
+ extra: {
161
+ topic,
162
+ data,
163
+ extra
164
+ }
165
+ });
166
+ const { data: modifiedData, extra: modifiedExtra } = socket.unstable__modifyResponse({
167
+ data,
168
+ extra
169
+ });
170
+ socket.adapter.triggerListeners({
171
+ topic,
172
+ data: modifiedData,
173
+ extra: modifiedExtra
174
+ });
175
+ socket.events.emitListenerEvent({
176
+ topic,
177
+ data: modifiedData,
178
+ extra: modifiedExtra
179
+ });
260
180
  };
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) : [];
181
+ const getQueryParams = () => socket.adapter.unstable_queryParamsMapper(socket.adapter.queryParams, socket.adapter.queryParamsConfig);
182
+ return {
183
+ socket,
184
+ adapter: socket.adapter,
185
+ logger,
186
+ getQueryParams,
187
+ onConnect,
188
+ onReconnect,
189
+ onDisconnect,
190
+ onListen,
191
+ onEmit,
192
+ onEmitError,
193
+ onConnected,
194
+ onDisconnected,
195
+ onError,
196
+ onEvent
273
197
  };
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;
198
+ };
199
+ //#endregion
200
+ //#region src/adapter/adapter.ts
201
+ var SocketAdapter = class {
202
+ name;
203
+ socket;
204
+ defaultExtra = void 0;
205
+ queryParams = void 0;
206
+ queryParamsConfig = void 0;
207
+ /** Config for the query params mapper */
208
+ unstable_queryParamsMapperConfig;
209
+ /** Method to get request data and transform them to the required format. */
210
+ unstable_queryParamsMapper = defaultMapper;
211
+ adapterOptions;
212
+ listenerOptions;
213
+ emitterOptions;
214
+ getConnector;
215
+ connected = false;
216
+ connecting = false;
217
+ reconnectionAttempts = 0;
218
+ forceClosed = false;
219
+ listeners = /* @__PURE__ */ new Map();
220
+ listen;
221
+ emit;
222
+ connect;
223
+ reconnect;
224
+ disconnect;
225
+ constructor(options) {
226
+ this.options = options;
227
+ this.name = options.name;
228
+ this.queryParams = options.queryParams;
229
+ if (options.defaultConnected) this.setConnected(options.defaultConnected);
230
+ if (options.defaultConnecting) this.setConnecting(options.defaultConnecting);
231
+ if (options.defaultReconnectionAttempts) this.setReconnectionAttempts(options.defaultReconnectionAttempts);
232
+ if (options.defaultForceClosed) this.setForceClosed(options.defaultForceClosed);
278
233
  }
279
- function spliceOne(list, index) {
280
- for (; index + 1 < list.length; index++) list[index] = list[index + 1];
281
- list.pop();
234
+ initialize(socket) {
235
+ this.socket = socket;
236
+ this.adapterOptions = {
237
+ ...this.adapterOptions,
238
+ ...socket.options.adapterOptions
239
+ };
240
+ const { listen, emit, connect, reconnect, disconnect } = this.getConnector();
241
+ this.listen = listen;
242
+ this.emit = emit;
243
+ this.connect = connect;
244
+ this.reconnect = reconnect;
245
+ this.disconnect = disconnect;
246
+ return this;
282
247
  }
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;
248
+ setQueryParams(queryParams) {
249
+ this.queryParams = queryParams;
250
+ return this;
287
251
  }
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
- });
252
+ setQueryParamsConfig(queryParamsConfig) {
253
+ this.queryParamsConfig = queryParamsConfig;
254
+ return this;
301
255
  }
302
- function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
303
- if (typeof emitter.on === "function") eventTargetAgnosticAddListener(emitter, "error", handler, flags);
256
+ setDefaultExtra(defaultExtra) {
257
+ this.defaultExtra = defaultExtra;
258
+ return this;
304
259
  }
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);
260
+ setOptions(adapterOptions) {
261
+ this.adapterOptions = adapterOptions;
262
+ return this;
313
263
  }
314
- }));
315
- //#endregion
316
- //#region src/listener/listener.ts
317
- /**
318
- * Represents a socket message listener bound to a specific topic. Use it to subscribe to
319
- * typed messages from WebSocket or Server-Sent Events connections via the socket adapter.
320
- */
321
- var Listener = class Listener {
322
- topic;
323
- params;
324
- options;
325
- constructor(socket, listenerOptions) {
326
- this.socket = socket;
264
+ setDefaultListenerOptions(listenerOptions) {
327
265
  this.listenerOptions = listenerOptions;
328
- const { topic, options } = listenerOptions;
329
- this.topic = topic;
330
- this.options = options;
331
- }
332
- /** Set adapter-specific listener options. */
333
- setOptions(options) {
334
- return this.clone({ options });
335
- }
336
- /** Set the URL path parameters for the topic (e.g., `:channelId`). */
337
- setParams(params) {
338
- return this.clone({ params });
266
+ return this;
339
267
  }
340
- /** Create a new listener instance with optional configuration overrides. */
341
- clone(options) {
342
- return new Listener(this.socket, {
343
- ...this.listenerOptions,
344
- ...options,
345
- topic: this.paramsMapper(options?.params || this.params)
346
- });
268
+ setDefaultEmitterOptions(emitterOptions) {
269
+ this.emitterOptions = emitterOptions;
270
+ return this;
347
271
  }
348
- /** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
349
- listen = (callback) => {
350
- this.socket.adapter.listen(this, callback);
351
- const removeListener = () => {
352
- this.socket.adapter.removeListener({
353
- topic: this.topic,
354
- callback
355
- });
356
- };
357
- return removeListener;
272
+ setQueryParamsMapperConfig = (config) => {
273
+ this.unstable_queryParamsMapperConfig = config;
274
+ return this;
358
275
  };
359
- paramsMapper = (params) => {
360
- let topic = this.listenerOptions.topic;
361
- if (params) Object.entries(params).forEach(([key, value]) => {
362
- topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
276
+ /**
277
+ * Set the query params mapping function which get triggered before request get sent
278
+ */
279
+ setQueryParamsMapper = (queryParamsMapper) => {
280
+ this.unstable_queryParamsMapper = ((queryParams) => queryParamsMapper(queryParams, this.unstable_queryParamsMapperConfig));
281
+ return this;
282
+ };
283
+ removeListener = ({ topic, callback }) => {
284
+ const listenerGroup = this.listeners.get(topic);
285
+ if (listenerGroup) {
286
+ const unmount = listenerGroup.get(callback);
287
+ this.socket.events.emitListenerRemoveEvent({ topic });
288
+ listenerGroup.delete(callback);
289
+ unmount?.();
290
+ return true;
291
+ }
292
+ return false;
293
+ };
294
+ triggerListeners = ({ topic, data, extra }) => {
295
+ const listenerGroup = this.listeners.get(topic);
296
+ if (listenerGroup) listenerGroup.forEach((_, action) => {
297
+ action({
298
+ data,
299
+ extra
300
+ });
363
301
  });
364
- return topic;
302
+ };
303
+ setConnected = (connected) => {
304
+ this.connected = connected;
305
+ return this;
306
+ };
307
+ setConnecting = (connecting) => {
308
+ this.connecting = connecting;
309
+ return this;
310
+ };
311
+ setReconnectionAttempts = (reconnectionAttempts) => {
312
+ this.reconnectionAttempts = reconnectionAttempts;
313
+ return this;
314
+ };
315
+ setForceClosed = (forceClosed) => {
316
+ this.forceClosed = forceClosed;
317
+ return this;
318
+ };
319
+ setConnector = (connector) => {
320
+ this.getConnector = () => {
321
+ return connector(getAdapterBindings(this.socket));
322
+ };
323
+ return this;
365
324
  };
366
325
  };
367
326
  //#endregion
368
- //#region src/emitter/emitter.ts
369
- /**
370
- * Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
371
- * over WebSocket or Server-Sent Events connections via the socket adapter.
372
- */
373
- var Emitter = class Emitter {
374
- topic;
375
- params;
376
- payload;
377
- options;
378
- /** @internal */
379
- unstable_payloadMapper;
380
- constructor(socket, emitterOptions, snapshot) {
381
- this.socket = socket;
382
- this.emitterOptions = emitterOptions;
383
- const { topic, options } = emitterOptions;
384
- this.topic = snapshot?.topic ?? topic;
385
- this.payload = snapshot?.payload;
386
- this.options = snapshot?.options ?? options;
387
- this.params = snapshot?.params;
388
- }
389
- /** Set adapter-specific emit options (e.g., acknowledgment, timeout). */
390
- setOptions(options) {
391
- return this.clone({ options });
392
- }
393
- /** Set the message payload to be emitted. */
394
- setPayload = (payload) => {
395
- return this.clone({ payload });
396
- };
397
- /** Set a mapper function that transforms the payload before it is sent. */
398
- setPayloadMapper = (payloadMapper) => {
399
- const cloned = this.clone(void 0);
400
- cloned.unstable_payloadMapper = payloadMapper;
401
- return cloned;
327
+ //#region src/utils/message-event.utils.ts
328
+ var parseMessageEvent = (event) => {
329
+ return {
330
+ ...parseResponse(event.data),
331
+ event
402
332
  };
403
- /** Set the URL path parameters for the topic (e.g., `:channelId`). */
404
- setParams(params) {
405
- return this.clone({ params });
333
+ };
334
+ //#endregion
335
+ //#region src/utils/socket.utils.ts
336
+ var getSocketUrl = (url, queryParams) => {
337
+ return `${url}${queryParams}`;
338
+ };
339
+ //#endregion
340
+ //#region src/utils/socket.errors.ts
341
+ var getSocketError = (event) => {
342
+ if ("code" in event) switch (event.code) {
343
+ case 1e3: return "Normal closure, meaning that the purpose for which the connection was established has been fulfilled.";
344
+ case 1001: return "An endpoint is \"going away\", such as a server going down or a browser having navigated away from a page.";
345
+ case 1002: return "An endpoint is terminating the connection due to a protocol error";
346
+ 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).";
347
+ case 1004: return "Reserved. The specific meaning might be defined in the future.";
348
+ case 1005: return "No status code was actually present.";
349
+ case 1006: return "The connection was closed abnormally, e.g., without sending or receiving a Close control frame";
350
+ 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).";
351
+ 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.";
352
+ case 1009: return "An endpoint is terminating the connection because it has received a message that is too big for it to process.";
353
+ 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");
354
+ case 1011: return "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.";
355
+ 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).";
356
+ default: return "Unknown reason";
406
357
  }
407
- paramsMapper = (params) => {
408
- let topic = this.emitterOptions.topic;
409
- if (params) Object.entries(params).forEach(([key, value]) => {
410
- topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
411
- });
412
- return topic;
413
- };
414
- /** Create a new emitter instance with optional configuration overrides. */
415
- clone(config) {
416
- const snapshot = {
417
- options: this.options,
418
- payload: this.payload,
419
- ...config,
420
- params: config?.params || this.params,
421
- topic: this.paramsMapper(config?.params || this.params)
358
+ if ("data" in event) return JSON.stringify(event.data);
359
+ return "There was an socket error";
360
+ };
361
+ //#endregion
362
+ //#region src/adapter-websockets/websocket-adapter.utils.ts
363
+ var getWebsocketAdapter = (url, adapterOptions) => {
364
+ /** istanbul ignore next */
365
+ try {
366
+ /** istanbul ignore next */
367
+ if (!window?.WebSocket) return null;
368
+ } catch {
369
+ return null;
370
+ }
371
+ class HyperFetchWebsocket extends WebSocket {
372
+ registeredHandlers = /* @__PURE__ */ new Map();
373
+ constructor(socketUrl, protocols) {
374
+ super(socketUrl, protocols);
375
+ }
376
+ addEventListener = (type, listener, options) => {
377
+ super.addEventListener(type, listener, options);
378
+ this.registeredHandlers.set(listener, {
379
+ type,
380
+ listener,
381
+ options
382
+ });
383
+ };
384
+ removeEventListener = (type, listener, options) => {
385
+ super.removeEventListener(type, listener, options);
386
+ this.registeredHandlers.delete(listener);
387
+ };
388
+ clearListeners = () => {
389
+ this.registeredHandlers.forEach(({ type, listener, options }) => {
390
+ if (!options?.disableCleanup) this.removeEventListener(type, listener, options);
391
+ });
422
392
  };
423
- const newInstance = new Emitter(this.socket, this.emitterOptions, snapshot);
424
- newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
425
- return newInstance;
426
393
  }
427
- /** Send the message through the socket adapter on the configured topic. */
428
- emit = (options = {}) => {
429
- const typedOptions = options;
430
- const instance = this.clone(typedOptions);
431
- this.socket.adapter.emit(instance);
432
- };
394
+ return new HyperFetchWebsocket(url, adapterOptions?.protocols);
433
395
  };
434
396
  //#endregion
435
- //#region src/adapter/adapter.bindings.ts
436
- var import_events = /* @__PURE__ */ __toESM(require_events());
437
- var getAdapterBindings = (socket) => {
438
- const { adapter } = socket;
439
- const logger = socket.loggerManager.initialize(socket, "Socket Bindings");
440
- const onConnect = () => {
441
- if (!socket.appManager.isOnline || adapter.connecting) {
442
- logger.warning({
443
- title: "Cannot initialize adapter.",
397
+ //#region src/adapter-websockets/websocket-adapter.ts
398
+ /** Create a preconfigured socket adapter for native WebSocket connections. */
399
+ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, logger, getQueryParams, onConnect, onReconnect, onDisconnect, onListen, onEmit, onConnected, onDisconnected, onError, onEvent }) => {
400
+ const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
401
+ let websocket;
402
+ let pingTimer;
403
+ let pongTimer;
404
+ let timeout;
405
+ const connect = async () => {
406
+ const url = getSocketUrl(socket.url, getQueryParams());
407
+ if (!onConnect()) return false;
408
+ clearTimeout(timeout);
409
+ websocket?.clearListeners();
410
+ websocket?.close(1e3);
411
+ const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
412
+ websocket = newWebsocket;
413
+ if (!newWebsocket) {
414
+ logger.error({
415
+ title: "Cannot connect to websocket",
444
416
  type: "system",
445
- extra: {
446
- connecting: adapter.connecting,
447
- online: socket.appManager.isOnline
448
- }
417
+ extra: { websocket }
449
418
  });
450
419
  return false;
451
420
  }
452
- socket.adapter.setForceClosed(false);
453
- socket.adapter.setConnecting(true);
454
- socket.adapter.setReconnectionAttempts(0);
455
- socket.events.emitConnecting({ connecting: true });
456
- return true;
457
- };
458
- const onDisconnect = () => {
459
- logger.debug({
460
- title: "Disconnecting",
461
- type: "system",
462
- extra: { reconnectionAttempts: adapter.reconnectionAttempts }
421
+ newWebsocket.clearListeners();
422
+ timeout = setTimeout(() => {
423
+ reconnect();
424
+ }, socket.reconnectTime);
425
+ /**
426
+ * Mount listeners
427
+ */
428
+ newWebsocket.addEventListener("open", () => {
429
+ clearTimeout(timeout);
430
+ onConnected();
431
+ onHeartbeat();
463
432
  });
464
- socket.adapter.setConnected(false);
465
- socket.adapter.setConnecting(false);
466
- socket.adapter.setForceClosed(true);
467
- socket.adapter.setReconnectionAttempts(0);
468
- return true;
469
- };
470
- const onReconnect = async ({ disconnect, connect }) => {
471
- const currentAttempts = adapter.reconnectionAttempts;
472
- socket.unstable_onReconnectCallbacks.forEach((callback) => {
473
- callback();
433
+ newWebsocket.addEventListener("close", (event) => {
434
+ clearTimeout(timeout);
435
+ onDisconnected();
436
+ clearTimers();
437
+ const error = getSocketError(event);
438
+ onError({ error: new Error(error) });
439
+ if (event.code !== 1e3) timeout = setTimeout(() => {
440
+ reconnect();
441
+ }, socket.reconnectTime);
474
442
  });
475
- socket.events.emitReconnecting({ attempts: currentAttempts });
476
- await disconnect();
477
- if (currentAttempts < socket.reconnectAttempts) {
478
- const nextAttempts = currentAttempts + 1;
479
- socket.adapter.setReconnectionAttempts(nextAttempts);
480
- logger.debug({
481
- title: "Reconnecting",
482
- type: "system",
483
- extra: { reconnectionAttempts: nextAttempts }
443
+ newWebsocket.addEventListener("message", (newEvent) => {
444
+ const { topic, data, event } = parseMessageEvent(newEvent);
445
+ onEvent({
446
+ topic,
447
+ data,
448
+ extra: event
484
449
  });
485
- await connect();
486
- if (!adapter.connected) socket.adapter.setReconnectionAttempts(nextAttempts);
487
- return true;
488
- }
489
- logger.error({
490
- title: "Stopped reconnecting",
491
- type: "system",
492
- extra: { reconnectionAttempts: currentAttempts }
493
- });
494
- socket.unstable_onReconnectFailedCallbacks.forEach((callback) => {
495
- callback();
450
+ onHeartbeat();
496
451
  });
497
- socket.events.emitReconnectingFailed({ attempts: currentAttempts });
498
- return false;
499
- };
500
- const onListen = ({ listener, callback, onUnmount = () => null }) => {
501
- (adapter.listeners.get(listener.topic) || adapter.listeners.set(listener.topic, /* @__PURE__ */ new Map()).get(listener.topic)).set(callback, onUnmount);
502
- return () => socket.adapter.removeListener({
503
- topic: listener.topic,
504
- callback
452
+ return new Promise((resolve) => {
453
+ if (newWebsocket.readyState === WebSocket.OPEN) {
454
+ resolve(true);
455
+ socket.adapter.setConnected(true);
456
+ socket.adapter.setConnecting(false);
457
+ return;
458
+ }
459
+ const resolveConnected = () => {
460
+ resolve(true);
461
+ newWebsocket.removeEventListener("open", resolveConnected);
462
+ };
463
+ const resolveDisconnected = () => {
464
+ resolve(false);
465
+ newWebsocket.removeEventListener("close", resolveDisconnected);
466
+ };
467
+ const resolveError = () => {
468
+ resolve(false);
469
+ newWebsocket.removeEventListener("error", resolveError);
470
+ };
471
+ newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
472
+ newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
473
+ newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
505
474
  });
506
475
  };
507
- const onEmit = async ({ emitter }) => {
508
- if (adapter.connecting || !adapter.connected) {
509
- logger.error({
510
- title: "Cannot emit event when connection is not open",
511
- type: "system",
512
- extra: {}
513
- });
514
- return null;
476
+ const disconnect = async () => {
477
+ if (!websocket) {
478
+ socket.adapter.setConnected(false);
479
+ socket.adapter.setConnecting(false);
480
+ return true;
515
481
  }
516
- emitter.payload = emitter.unstable_payloadMapper ? emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
517
- const emitterInstance = await socket.unstable__modifySend(emitter);
518
- socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
519
- return emitterInstance;
520
- };
521
- const onEmitError = ({ emitter, error }) => {
522
- socket.events.emitEmitterError({
523
- error,
524
- emitter
525
- });
526
- };
527
- const onConnected = () => {
528
- logger.info({
529
- title: "Connection open",
530
- type: "system",
531
- extra: {}
532
- });
533
- adapter.setConnected(true);
534
- adapter.setConnecting(false);
535
- adapter.setReconnectionAttempts(0);
536
- socket.events.emitConnecting({ connecting: false });
537
- socket.events.emitConnected();
538
- socket.unstable_onConnectedCallbacks.forEach((callback) => {
539
- callback();
540
- });
541
- };
542
- const onDisconnected = () => {
543
- logger.info({
544
- title: "Connection closed",
545
- type: "system",
546
- extra: {}
547
- });
548
- adapter.setConnected(false);
549
- adapter.setConnecting(false);
550
- socket.events.emitConnecting({ connecting: false });
551
- socket.events.emitDisconnected();
552
- socket.unstable_onDisconnectCallbacks.forEach((callback) => {
553
- callback();
554
- });
555
- };
556
- const onError = ({ error }) => {
557
- logger.info({
558
- title: "Error message",
559
- type: "system",
560
- extra: { error }
561
- });
562
- socket.unstable_onErrorCallbacks.forEach((callback) => {
563
- callback({ error });
564
- });
565
- socket.events.emitError({ error });
566
- };
567
- const onEvent = ({ topic, data, extra }) => {
568
- logger.info({
569
- title: "New event message",
570
- type: "system",
571
- extra: {
572
- topic,
573
- data,
574
- extra
482
+ const currentWebsocket = websocket;
483
+ const promise = new Promise((resolve) => {
484
+ if (currentWebsocket.readyState === WebSocket.CLOSED) {
485
+ resolve(true);
486
+ socket.adapter.setConnected(false);
487
+ socket.adapter.setConnecting(false);
488
+ return;
575
489
  }
490
+ const resolveDisconnected = () => {
491
+ resolve(true);
492
+ currentWebsocket.removeEventListener("close", resolveDisconnected);
493
+ };
494
+ currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
576
495
  });
577
- const { data: modifiedData, extra: modifiedExtra } = socket.unstable__modifyResponse({
578
- data,
579
- extra
580
- });
581
- socket.adapter.triggerListeners({
582
- topic,
583
- data: modifiedData,
584
- extra: modifiedExtra
496
+ onDisconnect();
497
+ currentWebsocket.close(1e3);
498
+ clearTimers();
499
+ return promise;
500
+ };
501
+ const reconnect = async () => {
502
+ await onReconnect({
503
+ disconnect,
504
+ connect
585
505
  });
586
- socket.events.emitListenerEvent({
506
+ };
507
+ const clearTimers = () => {
508
+ clearTimeout(pingTimer);
509
+ clearTimeout(pongTimer);
510
+ };
511
+ const sendEventMessage = ({ topic, payload }) => {
512
+ if (!websocket) return false;
513
+ websocket.send(JSON.stringify({
587
514
  topic,
588
- data: modifiedData,
589
- extra: modifiedExtra
515
+ data: payload
516
+ }));
517
+ return true;
518
+ };
519
+ const onHeartbeat = () => {
520
+ const { heartbeat = false, pingTimeout = Time.SEC * 5, pongTimeout = Time.SEC * 5, heartbeatMessage = "heartbeat" } = socket.adapter.adapterOptions || (
521
+ /* istanbul ignore next */
522
+ {});
523
+ if (socket.adapter.connecting || !heartbeat) return;
524
+ clearTimers();
525
+ pingTimer = setTimeout(() => {
526
+ sendEventMessage({
527
+ topic: "heartbeat",
528
+ payload: heartbeatMessage
529
+ });
530
+ pongTimer = setTimeout(() => {
531
+ websocket?.close();
532
+ }, pongTimeout);
533
+ }, pingTimeout);
534
+ };
535
+ const listen = (listener, callback) => {
536
+ return onListen({
537
+ listener,
538
+ callback
590
539
  });
591
540
  };
592
- const getQueryParams = () => socket.adapter.unstable_queryParamsMapper(socket.adapter.queryParams, socket.adapter.queryParamsConfig);
541
+ const emit = async (emitter) => {
542
+ const mappedEmitter = await onEmit({ emitter });
543
+ if (!mappedEmitter) return;
544
+ return sendEventMessage(mappedEmitter);
545
+ };
546
+ if (autoConnect) connect();
547
+ socket.appManager.events.onOnline(() => {
548
+ if (autoConnect && !socket.adapter.connected) connect();
549
+ });
593
550
  return {
594
- socket,
595
- adapter: socket.adapter,
596
- logger,
597
- getQueryParams,
598
- onConnect,
599
- onReconnect,
600
- onDisconnect,
601
- onListen,
602
- onEmit,
603
- onEmitError,
604
- onConnected,
605
- onDisconnected,
606
- onError,
607
- onEvent
551
+ connect,
552
+ reconnect,
553
+ disconnect,
554
+ listen,
555
+ emit
608
556
  };
609
- };
557
+ });
610
558
  //#endregion
611
- //#region src/adapter/adapter.ts
612
- var SocketAdapter = class {
613
- name;
614
- socket;
615
- defaultExtra;
616
- queryParams;
617
- queryParamsConfig;
618
- /** Config for the query params mapper */
619
- unstable_queryParamsMapperConfig;
620
- /** Method to get request data and transform them to the required format. */
621
- unstable_queryParamsMapper = defaultMapper;
622
- adapterOptions;
623
- listenerOptions;
624
- emitterOptions;
625
- getConnector;
626
- connected = false;
627
- connecting = false;
628
- reconnectionAttempts = 0;
629
- forceClosed = false;
630
- listeners = /* @__PURE__ */ new Map();
631
- listen;
632
- emit;
633
- connect;
634
- reconnect;
635
- disconnect;
636
- constructor(options) {
637
- this.options = options;
638
- this.name = options.name;
639
- this.queryParams = options.queryParams;
640
- if (options.defaultConnected) this.setConnected(options.defaultConnected);
641
- if (options.defaultConnecting) this.setConnecting(options.defaultConnecting);
642
- if (options.defaultReconnectionAttempts) this.setReconnectionAttempts(options.defaultReconnectionAttempts);
643
- if (options.defaultForceClosed) this.setForceClosed(options.defaultForceClosed);
644
- }
645
- initialize(socket) {
559
+ //#region src/emitter/emitter.ts
560
+ /**
561
+ * Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
562
+ * over WebSocket or Server-Sent Events connections via the socket adapter.
563
+ */
564
+ var Emitter = class Emitter {
565
+ topic;
566
+ params = void 0;
567
+ payload;
568
+ options;
569
+ /** @internal */
570
+ unstable_payloadMapper = void 0;
571
+ constructor(socket, emitterOptions, snapshot) {
646
572
  this.socket = socket;
647
- this.adapterOptions = {
648
- ...this.adapterOptions,
649
- ...socket.options.adapterOptions
650
- };
651
- const { listen, emit, connect, reconnect, disconnect } = this.getConnector();
652
- this.listen = listen;
653
- this.emit = emit;
654
- this.connect = connect;
655
- this.reconnect = reconnect;
656
- this.disconnect = disconnect;
657
- return this;
573
+ this.emitterOptions = emitterOptions;
574
+ const { topic, options } = emitterOptions;
575
+ this.topic = snapshot?.topic ?? topic;
576
+ this.payload = snapshot?.payload;
577
+ this.options = snapshot?.options ?? options;
578
+ this.params = snapshot?.params;
658
579
  }
659
- setQueryParams(queryParams) {
660
- this.queryParams = queryParams;
661
- return this;
580
+ /** Set adapter-specific emit options (e.g., acknowledgment, timeout). */
581
+ setOptions(options) {
582
+ return this.clone({ options });
662
583
  }
663
- setQueryParamsConfig(queryParamsConfig) {
664
- this.queryParamsConfig = queryParamsConfig;
665
- return this;
584
+ /** Set the message payload to be emitted. */
585
+ setPayload = (payload) => {
586
+ return this.clone({ payload });
587
+ };
588
+ /** Set a mapper function that transforms the payload before it is sent. */
589
+ setPayloadMapper = (payloadMapper) => {
590
+ const cloned = this.clone();
591
+ cloned.unstable_payloadMapper = payloadMapper;
592
+ return cloned;
593
+ };
594
+ /** Set the URL path parameters for the topic (e.g., `:channelId`). */
595
+ setParams(params) {
596
+ return this.clone({ params });
666
597
  }
667
- setDefaultExtra(defaultExtra) {
668
- this.defaultExtra = defaultExtra;
669
- return this;
598
+ paramsMapper = (params) => {
599
+ let topic = this.emitterOptions.topic;
600
+ if (params) Object.entries(params).forEach(([key, value]) => {
601
+ topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
602
+ });
603
+ return topic;
604
+ };
605
+ /** Create a new emitter instance with optional configuration overrides. */
606
+ clone(config) {
607
+ const snapshot = {
608
+ options: this.options,
609
+ payload: this.payload,
610
+ ...config,
611
+ params: config?.params || this.params,
612
+ topic: this.paramsMapper(config?.params || this.params)
613
+ };
614
+ const newInstance = new Emitter(this.socket, this.emitterOptions, snapshot);
615
+ newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
616
+ return newInstance;
670
617
  }
671
- setOptions(adapterOptions) {
672
- this.adapterOptions = adapterOptions;
673
- return this;
618
+ /** Send the message through the socket adapter on the configured topic. */
619
+ emit = (options = {}) => {
620
+ const typedOptions = options;
621
+ const instance = this.clone(typedOptions);
622
+ this.socket.adapter.emit(instance);
623
+ };
624
+ };
625
+ //#endregion
626
+ //#region ../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js
627
+ var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
628
+ var R = typeof Reflect === "object" ? Reflect : null;
629
+ var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply(target, receiver, args) {
630
+ return Function.prototype.apply.call(target, receiver, args);
631
+ };
632
+ var ReflectOwnKeys;
633
+ if (R && typeof R.ownKeys === "function") ReflectOwnKeys = R.ownKeys;
634
+ else if (Object.getOwnPropertySymbols) ReflectOwnKeys = function ReflectOwnKeys(target) {
635
+ return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
636
+ };
637
+ else ReflectOwnKeys = function ReflectOwnKeys(target) {
638
+ return Object.getOwnPropertyNames(target);
639
+ };
640
+ function ProcessEmitWarning(warning) {
641
+ if (console && console.warn) console.warn(warning);
674
642
  }
675
- setDefaultListenerOptions(listenerOptions) {
676
- this.listenerOptions = listenerOptions;
677
- return this;
643
+ var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
644
+ return value !== value;
645
+ };
646
+ function EventEmitter() {
647
+ EventEmitter.init.call(this);
678
648
  }
679
- setDefaultEmitterOptions(emitterOptions) {
680
- this.emitterOptions = emitterOptions;
681
- return this;
649
+ module.exports = EventEmitter;
650
+ module.exports.once = once;
651
+ EventEmitter.EventEmitter = EventEmitter;
652
+ EventEmitter.prototype._events = void 0;
653
+ EventEmitter.prototype._eventsCount = 0;
654
+ EventEmitter.prototype._maxListeners = void 0;
655
+ var defaultMaxListeners = 10;
656
+ function checkListener(listener) {
657
+ if (typeof listener !== "function") throw new TypeError("The \"listener\" argument must be of type Function. Received type " + typeof listener);
682
658
  }
683
- setQueryParamsMapperConfig = (config) => {
684
- this.unstable_queryParamsMapperConfig = config;
685
- return this;
686
- };
687
- /**
688
- * Set the query params mapping function which get triggered before request get sent
689
- */
690
- setQueryParamsMapper = (queryParamsMapper) => {
691
- this.unstable_queryParamsMapper = ((queryParams) => queryParamsMapper(queryParams, this.unstable_queryParamsMapperConfig));
692
- return this;
693
- };
694
- removeListener = ({ topic, callback }) => {
695
- const listenerGroup = this.listeners.get(topic);
696
- if (listenerGroup) {
697
- const unmount = listenerGroup.get(callback);
698
- this.socket.events.emitListenerRemoveEvent({ topic });
699
- listenerGroup.delete(callback);
700
- unmount?.();
701
- return true;
659
+ Object.defineProperty(EventEmitter, "defaultMaxListeners", {
660
+ enumerable: true,
661
+ get: function() {
662
+ return defaultMaxListeners;
663
+ },
664
+ set: function(arg) {
665
+ 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 + ".");
666
+ defaultMaxListeners = arg;
667
+ }
668
+ });
669
+ EventEmitter.init = function() {
670
+ if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
671
+ this._events = Object.create(null);
672
+ this._eventsCount = 0;
702
673
  }
703
- return false;
704
- };
705
- triggerListeners = ({ topic, data, extra }) => {
706
- const listenerGroup = this.listeners.get(topic);
707
- if (listenerGroup) listenerGroup.forEach((_, action) => {
708
- action({
709
- data,
710
- extra
711
- });
712
- });
674
+ this._maxListeners = this._maxListeners || void 0;
713
675
  };
714
- setConnected = (connected) => {
715
- this.connected = connected;
676
+ EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
677
+ 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 + ".");
678
+ this._maxListeners = n;
716
679
  return this;
717
680
  };
718
- setConnecting = (connecting) => {
719
- this.connecting = connecting;
720
- return this;
681
+ function _getMaxListeners(that) {
682
+ if (that._maxListeners === void 0) return EventEmitter.defaultMaxListeners;
683
+ return that._maxListeners;
684
+ }
685
+ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
686
+ return _getMaxListeners(this);
721
687
  };
722
- setReconnectionAttempts = (reconnectionAttempts) => {
723
- this.reconnectionAttempts = reconnectionAttempts;
724
- return this;
688
+ EventEmitter.prototype.emit = function emit(type) {
689
+ var args = [];
690
+ for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
691
+ var doError = type === "error";
692
+ var events = this._events;
693
+ if (events !== void 0) doError = doError && events.error === void 0;
694
+ else if (!doError) return false;
695
+ if (doError) {
696
+ var er;
697
+ if (args.length > 0) er = args[0];
698
+ if (er instanceof Error) throw er;
699
+ var err = /* @__PURE__ */ new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
700
+ err.context = er;
701
+ throw err;
702
+ }
703
+ var handler = events[type];
704
+ if (handler === void 0) return false;
705
+ if (typeof handler === "function") ReflectApply(handler, this, args);
706
+ else {
707
+ var len = handler.length;
708
+ var listeners = arrayClone(handler, len);
709
+ for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
710
+ }
711
+ return true;
725
712
  };
726
- setForceClosed = (forceClosed) => {
727
- this.forceClosed = forceClosed;
728
- return this;
713
+ function _addListener(target, type, listener, prepend) {
714
+ var m;
715
+ var events;
716
+ var existing;
717
+ checkListener(listener);
718
+ events = target._events;
719
+ if (events === void 0) {
720
+ events = target._events = Object.create(null);
721
+ target._eventsCount = 0;
722
+ } else {
723
+ if (events.newListener !== void 0) {
724
+ target.emit("newListener", type, listener.listener ? listener.listener : listener);
725
+ events = target._events;
726
+ }
727
+ existing = events[type];
728
+ }
729
+ if (existing === void 0) {
730
+ existing = events[type] = listener;
731
+ ++target._eventsCount;
732
+ } else {
733
+ if (typeof existing === "function") existing = events[type] = prepend ? [listener, existing] : [existing, listener];
734
+ else if (prepend) existing.unshift(listener);
735
+ else existing.push(listener);
736
+ m = _getMaxListeners(target);
737
+ if (m > 0 && existing.length > m && !existing.warned) {
738
+ existing.warned = true;
739
+ var w = /* @__PURE__ */ new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
740
+ w.name = "MaxListenersExceededWarning";
741
+ w.emitter = target;
742
+ w.type = type;
743
+ w.count = existing.length;
744
+ ProcessEmitWarning(w);
745
+ }
746
+ }
747
+ return target;
748
+ }
749
+ EventEmitter.prototype.addListener = function addListener(type, listener) {
750
+ return _addListener(this, type, listener, false);
729
751
  };
730
- setConnector = (connector) => {
731
- this.getConnector = () => {
732
- return connector(getAdapterBindings(this.socket));
733
- };
734
- return this;
752
+ EventEmitter.prototype.on = EventEmitter.prototype.addListener;
753
+ EventEmitter.prototype.prependListener = function prependListener(type, listener) {
754
+ return _addListener(this, type, listener, true);
735
755
  };
736
- };
737
- //#endregion
738
- //#region src/adapter-websockets/websocket-adapter.utils.ts
739
- var getWebsocketAdapter = (url, adapterOptions) => {
740
- /** istanbul ignore next */
741
- try {
742
- /** istanbul ignore next */
743
- if (!window?.WebSocket) return null;
744
- } catch (error) {
745
- return null;
746
- }
747
- class HyperFetchWebsocket extends WebSocket {
748
- registeredHandlers = /* @__PURE__ */ new Map();
749
- constructor(socketUrl, protocols) {
750
- super(socketUrl, protocols);
756
+ function onceWrapper() {
757
+ if (!this.fired) {
758
+ this.target.removeListener(this.type, this.wrapFn);
759
+ this.fired = true;
760
+ if (arguments.length === 0) return this.listener.call(this.target);
761
+ return this.listener.apply(this.target, arguments);
751
762
  }
752
- addEventListener = (type, listener, options) => {
753
- super.addEventListener(type, listener, options);
754
- this.registeredHandlers.set(listener, {
755
- type,
756
- listener,
757
- options
758
- });
759
- };
760
- removeEventListener = (type, listener, options) => {
761
- super.removeEventListener(type, listener, options);
762
- this.registeredHandlers.delete(listener);
763
- };
764
- clearListeners = () => {
765
- this.registeredHandlers.forEach(({ type, listener, options }) => {
766
- if (!options?.disableCleanup) this.removeEventListener(type, listener, options);
767
- });
763
+ }
764
+ function _onceWrap(target, type, listener) {
765
+ var state = {
766
+ fired: false,
767
+ wrapFn: void 0,
768
+ target,
769
+ type,
770
+ listener
768
771
  };
772
+ var wrapped = onceWrapper.bind(state);
773
+ wrapped.listener = listener;
774
+ state.wrapFn = wrapped;
775
+ return wrapped;
769
776
  }
770
- return new HyperFetchWebsocket(url, adapterOptions?.protocols);
771
- };
772
- //#endregion
773
- //#region src/utils/message-event.utils.ts
774
- var parseMessageEvent = (event) => {
775
- return {
776
- ...parseResponse(event.data),
777
- event
777
+ EventEmitter.prototype.once = function once(type, listener) {
778
+ checkListener(listener);
779
+ this.on(type, _onceWrap(this, type, listener));
780
+ return this;
778
781
  };
779
- };
780
- //#endregion
781
- //#region src/utils/socket.utils.ts
782
- var getSocketUrl = (url, queryParams) => {
783
- return `${url}${queryParams}`;
784
- };
785
- //#endregion
786
- //#region src/utils/socket.errors.ts
787
- var getSocketError = (event) => {
788
- if ("code" in event) switch (event.code) {
789
- case 1e3: return "Normal closure, meaning that the purpose for which the connection was established has been fulfilled.";
790
- case 1001: return "An endpoint is \"going away\", such as a server going down or a browser having navigated away from a page.";
791
- case 1002: return "An endpoint is terminating the connection due to a protocol error";
792
- 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).";
793
- case 1004: return "Reserved. The specific meaning might be defined in the future.";
794
- case 1005: return "No status code was actually present.";
795
- case 1006: return "The connection was closed abnormally, e.g., without sending or receiving a Close control frame";
796
- 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).";
797
- 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.";
798
- case 1009: return "An endpoint is terminating the connection because it has received a message that is too big for it to process.";
799
- 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");
800
- case 1011: return "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.";
801
- 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).";
802
- default: return "Unknown reason";
803
- }
804
- if ("data" in event) return JSON.stringify(event.data);
805
- return "There was an socket error";
806
- };
807
- //#endregion
808
- //#region src/adapter-websockets/websocket-adapter.ts
809
- /** Create a preconfigured socket adapter for native WebSocket connections. */
810
- var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, logger, getQueryParams, onConnect, onReconnect, onDisconnect, onListen, onEmit, onConnected, onDisconnected, onError, onEvent }) => {
811
- const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
812
- let websocket;
813
- let pingTimer;
814
- let pongTimer;
815
- let timeout;
816
- const connect = async () => {
817
- const url = getSocketUrl(socket.url, getQueryParams());
818
- if (!onConnect()) return Promise.resolve(false);
819
- clearTimeout(timeout);
820
- websocket?.clearListeners();
821
- websocket?.close(1e3);
822
- const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
823
- websocket = newWebsocket;
824
- if (!newWebsocket) {
825
- logger.error({
826
- title: "Cannot connect to websocket",
827
- type: "system",
828
- extra: { websocket }
829
- });
830
- return Promise.resolve(false);
831
- }
832
- newWebsocket.clearListeners();
833
- timeout = setTimeout(() => {
834
- reconnect();
835
- }, socket.reconnectTime);
836
- /**
837
- * Mount listeners
838
- */
839
- newWebsocket.addEventListener("open", () => {
840
- clearTimeout(timeout);
841
- onConnected();
842
- onHeartbeat();
843
- });
844
- newWebsocket.addEventListener("close", (event) => {
845
- clearTimeout(timeout);
846
- onDisconnected();
847
- clearTimers();
848
- const error = getSocketError(event);
849
- onError({ error: new Error(error) });
850
- if (event.code !== 1e3) timeout = setTimeout(() => {
851
- reconnect();
852
- }, socket.reconnectTime);
853
- });
854
- newWebsocket.addEventListener("message", (newEvent) => {
855
- const { topic, data, event } = parseMessageEvent(newEvent);
856
- onEvent({
857
- topic,
858
- data,
859
- extra: event
860
- });
861
- onHeartbeat();
862
- });
863
- return new Promise((resolve) => {
864
- if (newWebsocket.readyState === WebSocket.OPEN) {
865
- resolve(true);
866
- socket.adapter.setConnected(true);
867
- socket.adapter.setConnecting(false);
868
- return;
782
+ EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
783
+ checkListener(listener);
784
+ this.prependListener(type, _onceWrap(this, type, listener));
785
+ return this;
786
+ };
787
+ EventEmitter.prototype.removeListener = function removeListener(type, listener) {
788
+ var list, events, position, i, originalListener;
789
+ checkListener(listener);
790
+ events = this._events;
791
+ if (events === void 0) return this;
792
+ list = events[type];
793
+ if (list === void 0) return this;
794
+ if (list === listener || list.listener === listener) if (--this._eventsCount === 0) this._events = Object.create(null);
795
+ else {
796
+ delete events[type];
797
+ if (events.removeListener) this.emit("removeListener", type, list.listener || listener);
798
+ }
799
+ else if (typeof list !== "function") {
800
+ position = -1;
801
+ for (i = list.length - 1; i >= 0; i--) if (list[i] === listener || list[i].listener === listener) {
802
+ originalListener = list[i].listener;
803
+ position = i;
804
+ break;
869
805
  }
870
- const resolveConnected = () => {
871
- resolve(true);
872
- newWebsocket.removeEventListener("open", resolveConnected);
873
- };
874
- const resolveDisconnected = () => {
875
- resolve(false);
876
- newWebsocket.removeEventListener("close", resolveDisconnected);
877
- };
878
- const resolveError = () => {
879
- resolve(false);
880
- newWebsocket.removeEventListener("error", resolveError);
881
- };
882
- newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
883
- newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
884
- newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
885
- });
806
+ if (position < 0) return this;
807
+ if (position === 0) list.shift();
808
+ else spliceOne(list, position);
809
+ if (list.length === 1) events[type] = list[0];
810
+ if (events.removeListener !== void 0) this.emit("removeListener", type, originalListener || listener);
811
+ }
812
+ return this;
886
813
  };
887
- const disconnect = async () => {
888
- if (!websocket) {
889
- socket.adapter.setConnected(false);
890
- socket.adapter.setConnecting(false);
891
- return Promise.resolve(true);
814
+ EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
815
+ EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
816
+ var listeners, events = this._events, i;
817
+ if (events === void 0) return this;
818
+ if (events.removeListener === void 0) {
819
+ if (arguments.length === 0) {
820
+ this._events = Object.create(null);
821
+ this._eventsCount = 0;
822
+ } else if (events[type] !== void 0) if (--this._eventsCount === 0) this._events = Object.create(null);
823
+ else delete events[type];
824
+ return this;
892
825
  }
893
- const currentWebsocket = websocket;
894
- const promise = new Promise((resolve) => {
895
- if (currentWebsocket.readyState === WebSocket.CLOSED) {
896
- resolve(true);
897
- socket.adapter.setConnected(false);
898
- socket.adapter.setConnecting(false);
899
- return;
826
+ if (arguments.length === 0) {
827
+ var keys = Object.keys(events);
828
+ var key;
829
+ for (i = 0; i < keys.length; ++i) {
830
+ key = keys[i];
831
+ if (key === "removeListener") continue;
832
+ this.removeAllListeners(key);
900
833
  }
901
- const resolveDisconnected = () => {
902
- resolve(true);
903
- currentWebsocket.removeEventListener("close", resolveDisconnected);
904
- };
905
- currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
906
- });
907
- onDisconnect();
908
- currentWebsocket.close(1e3);
909
- clearTimers();
910
- return promise;
834
+ this.removeAllListeners("removeListener");
835
+ this._events = Object.create(null);
836
+ this._eventsCount = 0;
837
+ return this;
838
+ }
839
+ listeners = events[type];
840
+ if (typeof listeners === "function") this.removeListener(type, listeners);
841
+ else if (listeners !== void 0) for (i = listeners.length - 1; i >= 0; i--) this.removeListener(type, listeners[i]);
842
+ return this;
911
843
  };
912
- const reconnect = async () => {
913
- await onReconnect({
914
- disconnect,
915
- connect
916
- });
844
+ function _listeners(target, type, unwrap) {
845
+ var events = target._events;
846
+ if (events === void 0) return [];
847
+ var evlistener = events[type];
848
+ if (evlistener === void 0) return [];
849
+ if (typeof evlistener === "function") return unwrap ? [evlistener.listener || evlistener] : [evlistener];
850
+ return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
851
+ }
852
+ EventEmitter.prototype.listeners = function listeners(type) {
853
+ return _listeners(this, type, true);
917
854
  };
918
- const clearTimers = () => {
919
- clearTimeout(pingTimer);
920
- clearTimeout(pongTimer);
855
+ EventEmitter.prototype.rawListeners = function rawListeners(type) {
856
+ return _listeners(this, type, false);
921
857
  };
922
- const sendEventMessage = ({ topic, payload }) => {
923
- if (!websocket) return false;
924
- websocket.send(JSON.stringify({
925
- topic,
926
- data: payload
927
- }));
928
- return true;
858
+ EventEmitter.listenerCount = function(emitter, type) {
859
+ if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type);
860
+ else return listenerCount.call(emitter, type);
929
861
  };
930
- const onHeartbeat = () => {
931
- const { heartbeat = false, pingTimeout = Time.SEC * 5, pongTimeout = Time.SEC * 5, heartbeatMessage = "heartbeat" } = socket.adapter.adapterOptions || (
932
- /* istanbul ignore next */
933
- {});
934
- if (socket.adapter.connecting || !heartbeat) return;
935
- clearTimers();
936
- pingTimer = setTimeout(() => {
937
- sendEventMessage({
938
- topic: "heartbeat",
939
- payload: heartbeatMessage
940
- });
941
- pongTimer = setTimeout(() => {
942
- websocket?.close();
943
- }, pongTimeout);
944
- }, pingTimeout);
862
+ EventEmitter.prototype.listenerCount = listenerCount;
863
+ function listenerCount(type) {
864
+ var events = this._events;
865
+ if (events !== void 0) {
866
+ var evlistener = events[type];
867
+ if (typeof evlistener === "function") return 1;
868
+ else if (evlistener !== void 0) return evlistener.length;
869
+ }
870
+ return 0;
871
+ }
872
+ EventEmitter.prototype.eventNames = function eventNames() {
873
+ return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
945
874
  };
946
- const listen = (listener, callback) => {
947
- return onListen({
948
- listener,
949
- callback
875
+ function arrayClone(arr, n) {
876
+ var copy = new Array(n);
877
+ for (var i = 0; i < n; ++i) copy[i] = arr[i];
878
+ return copy;
879
+ }
880
+ function spliceOne(list, index) {
881
+ for (; index + 1 < list.length; index++) list[index] = list[index + 1];
882
+ list.pop();
883
+ }
884
+ function unwrapListeners(arr) {
885
+ var ret = new Array(arr.length);
886
+ for (var i = 0; i < ret.length; ++i) ret[i] = arr[i].listener || arr[i];
887
+ return ret;
888
+ }
889
+ function once(emitter, name) {
890
+ return new Promise(function(resolve, reject) {
891
+ function errorListener(err) {
892
+ emitter.removeListener(name, resolver);
893
+ reject(err);
894
+ }
895
+ function resolver() {
896
+ if (typeof emitter.removeListener === "function") emitter.removeListener("error", errorListener);
897
+ resolve([].slice.call(arguments));
898
+ }
899
+ eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
900
+ if (name !== "error") addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
950
901
  });
902
+ }
903
+ function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
904
+ if (typeof emitter.on === "function") eventTargetAgnosticAddListener(emitter, "error", handler, flags);
905
+ }
906
+ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
907
+ if (typeof emitter.on === "function") if (flags.once) emitter.once(name, listener);
908
+ else emitter.on(name, listener);
909
+ else if (typeof emitter.addEventListener === "function") emitter.addEventListener(name, function wrapListener(arg) {
910
+ if (flags.once) emitter.removeEventListener(name, wrapListener);
911
+ listener(arg);
912
+ });
913
+ else throw new TypeError("The \"emitter\" argument must be of type EventEmitter. Received type " + typeof emitter);
914
+ }
915
+ }));
916
+ //#endregion
917
+ //#region src/listener/listener.ts
918
+ /**
919
+ * Represents a socket message listener bound to a specific topic. Use it to subscribe to
920
+ * typed messages from WebSocket or Server-Sent Events connections via the socket adapter.
921
+ */
922
+ var Listener = class Listener {
923
+ topic;
924
+ params = void 0;
925
+ options = void 0;
926
+ constructor(socket, listenerOptions) {
927
+ this.socket = socket;
928
+ this.listenerOptions = listenerOptions;
929
+ const { topic, options } = listenerOptions;
930
+ this.topic = topic;
931
+ this.options = options;
932
+ }
933
+ /** Set adapter-specific listener options. */
934
+ setOptions(options) {
935
+ return this.clone({ options });
936
+ }
937
+ /** Set the URL path parameters for the topic (e.g., `:channelId`). */
938
+ setParams(params) {
939
+ return this.clone({ params });
940
+ }
941
+ /** Create a new listener instance with optional configuration overrides. */
942
+ clone(options) {
943
+ return new Listener(this.socket, {
944
+ ...this.listenerOptions,
945
+ ...options,
946
+ topic: this.paramsMapper(options?.params || this.params)
947
+ });
948
+ }
949
+ /** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
950
+ listen = (callback) => {
951
+ this.socket.adapter.listen(this, callback);
952
+ const removeListener = () => {
953
+ this.socket.adapter.removeListener({
954
+ topic: this.topic,
955
+ callback
956
+ });
957
+ };
958
+ return removeListener;
951
959
  };
952
- const emit = async (emitter) => {
953
- const mappedEmitter = await onEmit({ emitter });
954
- if (!mappedEmitter) return;
955
- return sendEventMessage(mappedEmitter);
956
- };
957
- if (autoConnect) connect();
958
- socket.appManager.events.onOnline(() => {
959
- if (autoConnect && !socket.adapter.connected) connect();
960
- });
961
- return {
962
- connect,
963
- reconnect,
964
- disconnect,
965
- listen,
966
- emit
960
+ paramsMapper = (params) => {
961
+ let topic = this.listenerOptions.topic;
962
+ if (params) Object.entries(params).forEach(([key, value]) => {
963
+ topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
964
+ });
965
+ return topic;
967
966
  };
968
- });
967
+ };
969
968
  //#endregion
970
969
  //#region src/socket/socket.ts
970
+ var import_events = /* @__PURE__ */ __toESM(require_events());
971
971
  var Socket = class {
972
972
  emitter = new import_events.default();
973
973
  events = getSocketEvents(this.emitter);
@@ -1298,7 +1298,7 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
1298
1298
  try {
1299
1299
  /** istanbul ignore next */
1300
1300
  if (!window?.EventSource) return null;
1301
- } catch (error) {
1301
+ } catch {
1302
1302
  return null;
1303
1303
  }
1304
1304
  class HyperFetchEventSource extends EventSource {
@@ -1400,18 +1400,18 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
1400
1400
  if (!sse) {
1401
1401
  adapter.setConnected(false);
1402
1402
  adapter.setConnecting(false);
1403
- return Promise.resolve(true);
1403
+ return true;
1404
1404
  }
1405
1405
  const currentSse = sse;
1406
1406
  if (currentSse.readyState === EventSource.CLOSED) {
1407
1407
  adapter.setConnected(false);
1408
1408
  adapter.setConnecting(false);
1409
- return Promise.resolve(true);
1409
+ return true;
1410
1410
  }
1411
1411
  onDisconnect();
1412
1412
  currentSse.close();
1413
1413
  onDisconnected();
1414
- return Promise.resolve(true);
1414
+ return true;
1415
1415
  };
1416
1416
  const reconnect = () => {
1417
1417
  onReconnect({
@@ -1500,7 +1500,7 @@ var createSocketRecursiveProxy = ({ socket, path, sdkKeys, options }) => {
1500
1500
  const sdkPath = currentSdkKeys.join(".");
1501
1501
  let pathSegment = key;
1502
1502
  if (key.startsWith("$") && !LEAF_KEYS.has(key)) pathSegment = `:${key.slice(1)}`;
1503
- else if (options?.camelCaseToKebabCase) pathSegment = key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
1503
+ else if (options?.camelCaseToKebabCase) pathSegment = key.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
1504
1504
  if (LEAF_KEYS.has(key)) {
1505
1505
  const topic = path.join("/");
1506
1506
  let instance;