@hyper-fetch/sockets 8.1.1 → 8.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +81 -28
- package/__tests__/e2e/e2e.connection.spec.ts +1 -1
- package/__tests__/e2e/e2e.edge-cases.spec.ts +1 -1
- package/__tests__/e2e/e2e.emitters.spec.ts +1 -1
- package/__tests__/e2e/e2e.heartbeat.spec.ts +4 -4
- package/__tests__/features/adapter/adapter.base.spec.ts +1 -0
- package/__tests__/features/adapter/adapter.bindings.spec.ts +2 -1
- package/__tests__/features/adapter/adapter.connection.spec.ts +2 -2
- package/__tests__/features/adapter/adapter.error.spec.ts +1 -1
- package/__tests__/features/adapter/adapter.sse.connection.spec.ts +2 -2
- package/__tests__/features/adapter/adapter.sse.spec.ts +6 -6
- package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +1 -1
- package/__tests__/features/adapter/adapter.websocket.spec.ts +5 -5
- package/__tests__/features/listener/listener.listen.spec.ts +1 -1
- package/__tests__/features/listener/listener.sse.spec.ts +2 -2
- package/__tests__/features/listener/listener.typescript.spec.ts +0 -1
- package/__tests__/features/sdk/sdk.base.spec.ts +11 -14
- package/__tests__/features/sdk/sdk.configuration.spec.ts +9 -11
- package/__tests__/features/sdk/sdk.types.spec.ts +303 -0
- package/__tests__/features/socket/socket.base.spec.ts +4 -4
- package/__tests__/features/socket/socket.callbacks.spec.ts +1 -1
- package/__tests__/features/socket/socket.methods.spec.ts +1 -2
- package/__tests__/features/socket/socket.misc.spec.ts +3 -3
- package/__tests__/features/socket/socket.utils.spec.ts +0 -1
- package/__tests__/tsconfig.json +4 -17
- package/__tests__/utils/client.utils.ts +1 -1
- package/__tests__/utils/emitter.utils.ts +1 -2
- package/__tests__/utils/listener.utils.ts +2 -3
- package/__tests__/utils/socket.utils.ts +2 -2
- package/dist/adapter/adapter.bindings.d.ts +3 -3
- package/dist/adapter/adapter.bindings.d.ts.map +1 -1
- package/dist/adapter/adapter.d.ts +4 -4
- package/dist/adapter/adapter.d.ts.map +1 -1
- package/dist/adapter/adapter.types.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.d.ts +2 -1
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.d.ts +1 -0
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -1
- package/dist/emitter/emitter.d.ts +11 -1
- package/dist/emitter/emitter.d.ts.map +1 -1
- package/dist/emitter/emitter.types.d.ts +62 -0
- package/dist/emitter/emitter.types.d.ts.map +1 -1
- package/dist/index.mjs +862 -842
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +9 -1
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/listener/listener.types.d.ts +67 -0
- package/dist/listener/listener.types.d.ts.map +1 -1
- package/dist/sdk/sdk.d.ts +27 -5
- package/dist/sdk/sdk.d.ts.map +1 -1
- package/dist/socket/socket.create.d.ts +1 -1
- package/dist/socket/socket.create.d.ts.map +1 -1
- package/dist/socket/socket.d.ts +5 -5
- package/dist/socket/socket.d.ts.map +1 -1
- package/dist/socket/socket.events.d.ts +2 -2
- package/dist/socket/socket.events.d.ts.map +1 -1
- package/dist/socket/socket.types.d.ts +1 -1
- package/dist/socket/socket.types.d.ts.map +1 -1
- package/dist/socket/socket.utils.d.ts.map +1 -1
- package/dist/types/tuple.types.d.ts +1 -1
- package/dist/types/tuple.types.d.ts.map +1 -1
- package/dist/utils/socket.errors.d.ts.map +1 -1
- package/package.json +8 -8
- package/src/adapter/adapter.bindings.ts +3 -3
- package/src/adapter/adapter.ts +8 -8
- package/src/adapter/adapter.types.ts +1 -0
- package/src/adapter-sse/sse-adapter.ts +9 -8
- package/src/adapter-sse/sse-adapter.utils.ts +4 -4
- package/src/adapter-websockets/websocket-adapter.ts +12 -11
- package/src/adapter-websockets/websocket-adapter.utils.ts +4 -4
- package/src/emitter/emitter.ts +15 -6
- package/src/emitter/emitter.types.ts +69 -1
- package/src/listener/listener.ts +12 -5
- package/src/listener/listener.types.ts +73 -1
- package/src/sdk/sdk.ts +64 -13
- package/src/socket/socket.create.ts +1 -1
- package/src/socket/socket.events.ts +3 -4
- package/src/socket/socket.ts +8 -9
- package/src/socket/socket.types.ts +1 -1
- package/src/socket/socket.utils.ts +3 -2
- package/src/types/tuple.types.ts +1 -1
- package/src/utils/socket.errors.ts +26 -13
- package/tsconfig.json +20 -2
- package/vite.config.ts +30 -21
- package/.eslintrc.cjs +0 -12
package/dist/index.mjs
CHANGED
|
@@ -22,933 +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
|
|
26
|
-
var
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
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
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
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
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
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
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
events
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
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
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
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
|
-
|
|
152
|
-
|
|
153
|
-
return
|
|
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
|
-
|
|
156
|
-
if (!
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
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
|
-
|
|
164
|
-
|
|
165
|
-
|
|
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
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
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
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
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
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
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
|
-
|
|
255
|
-
|
|
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
|
-
|
|
258
|
-
|
|
259
|
-
|
|
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
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
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
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
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
|
-
|
|
280
|
-
|
|
281
|
-
|
|
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
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
return ret;
|
|
248
|
+
setQueryParams(queryParams) {
|
|
249
|
+
this.queryParams = queryParams;
|
|
250
|
+
return this;
|
|
287
251
|
}
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
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
|
-
|
|
303
|
-
|
|
256
|
+
setDefaultExtra(defaultExtra) {
|
|
257
|
+
this.defaultExtra = defaultExtra;
|
|
258
|
+
return this;
|
|
304
259
|
}
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
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
|
-
var Listener = class Listener {
|
|
318
|
-
topic;
|
|
319
|
-
params;
|
|
320
|
-
options;
|
|
321
|
-
constructor(socket, listenerOptions) {
|
|
322
|
-
this.socket = socket;
|
|
264
|
+
setDefaultListenerOptions(listenerOptions) {
|
|
323
265
|
this.listenerOptions = listenerOptions;
|
|
324
|
-
|
|
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 });
|
|
266
|
+
return this;
|
|
333
267
|
}
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
...options,
|
|
338
|
-
topic: this.paramsMapper(options?.params || this.params)
|
|
339
|
-
});
|
|
268
|
+
setDefaultEmitterOptions(emitterOptions) {
|
|
269
|
+
this.emitterOptions = emitterOptions;
|
|
270
|
+
return this;
|
|
340
271
|
}
|
|
341
|
-
|
|
342
|
-
this.
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
272
|
+
setQueryParamsMapperConfig = (config) => {
|
|
273
|
+
this.unstable_queryParamsMapperConfig = config;
|
|
274
|
+
return this;
|
|
275
|
+
};
|
|
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
|
|
347
300
|
});
|
|
301
|
+
});
|
|
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));
|
|
348
322
|
};
|
|
349
|
-
return
|
|
323
|
+
return this;
|
|
350
324
|
};
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
325
|
+
};
|
|
326
|
+
//#endregion
|
|
327
|
+
//#region src/utils/message-event.utils.ts
|
|
328
|
+
var parseMessageEvent = (event) => {
|
|
329
|
+
return {
|
|
330
|
+
...parseResponse(event.data),
|
|
331
|
+
event
|
|
357
332
|
};
|
|
358
333
|
};
|
|
359
334
|
//#endregion
|
|
360
|
-
//#region src/
|
|
361
|
-
var
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
return
|
|
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";
|
|
379
357
|
}
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
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;
|
|
390
370
|
}
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
}
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
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
|
+
});
|
|
405
392
|
};
|
|
406
|
-
const newInstance = new Emitter(this.socket, this.emitterOptions, snapshot);
|
|
407
|
-
newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
|
|
408
|
-
return newInstance;
|
|
409
393
|
}
|
|
410
|
-
|
|
411
|
-
const typedOptions = options;
|
|
412
|
-
const instance = this.clone(typedOptions);
|
|
413
|
-
this.socket.adapter.emit(instance);
|
|
414
|
-
};
|
|
394
|
+
return new HyperFetchWebsocket(url, adapterOptions?.protocols);
|
|
415
395
|
};
|
|
416
396
|
//#endregion
|
|
417
|
-
//#region src/adapter/adapter.
|
|
418
|
-
|
|
419
|
-
var
|
|
420
|
-
const
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
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",
|
|
426
416
|
type: "system",
|
|
427
|
-
extra: {
|
|
428
|
-
connecting: adapter.connecting,
|
|
429
|
-
online: socket.appManager.isOnline
|
|
430
|
-
}
|
|
417
|
+
extra: { websocket }
|
|
431
418
|
});
|
|
432
419
|
return false;
|
|
433
420
|
}
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
socket.
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
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();
|
|
445
432
|
});
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
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);
|
|
456
442
|
});
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
title: "Reconnecting",
|
|
464
|
-
type: "system",
|
|
465
|
-
extra: { reconnectionAttempts: nextAttempts }
|
|
443
|
+
newWebsocket.addEventListener("message", (newEvent) => {
|
|
444
|
+
const { topic, data, event } = parseMessageEvent(newEvent);
|
|
445
|
+
onEvent({
|
|
446
|
+
topic,
|
|
447
|
+
data,
|
|
448
|
+
extra: event
|
|
466
449
|
});
|
|
467
|
-
|
|
468
|
-
if (!adapter.connected) socket.adapter.setReconnectionAttempts(nextAttempts);
|
|
469
|
-
return true;
|
|
470
|
-
}
|
|
471
|
-
logger.error({
|
|
472
|
-
title: "Stopped reconnecting",
|
|
473
|
-
type: "system",
|
|
474
|
-
extra: { reconnectionAttempts: currentAttempts }
|
|
475
|
-
});
|
|
476
|
-
socket.unstable_onReconnectFailedCallbacks.forEach((callback) => {
|
|
477
|
-
callback();
|
|
450
|
+
onHeartbeat();
|
|
478
451
|
});
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
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 });
|
|
487
474
|
});
|
|
488
475
|
};
|
|
489
|
-
const
|
|
490
|
-
if (
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
extra: {}
|
|
495
|
-
});
|
|
496
|
-
return null;
|
|
476
|
+
const disconnect = async () => {
|
|
477
|
+
if (!websocket) {
|
|
478
|
+
socket.adapter.setConnected(false);
|
|
479
|
+
socket.adapter.setConnecting(false);
|
|
480
|
+
return true;
|
|
497
481
|
}
|
|
498
|
-
|
|
499
|
-
const
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
error,
|
|
506
|
-
emitter
|
|
507
|
-
});
|
|
508
|
-
};
|
|
509
|
-
const onConnected = () => {
|
|
510
|
-
logger.info({
|
|
511
|
-
title: "Connection open",
|
|
512
|
-
type: "system",
|
|
513
|
-
extra: {}
|
|
514
|
-
});
|
|
515
|
-
adapter.setConnected(true);
|
|
516
|
-
adapter.setConnecting(false);
|
|
517
|
-
adapter.setReconnectionAttempts(0);
|
|
518
|
-
socket.events.emitConnecting({ connecting: false });
|
|
519
|
-
socket.events.emitConnected();
|
|
520
|
-
socket.unstable_onConnectedCallbacks.forEach((callback) => {
|
|
521
|
-
callback();
|
|
522
|
-
});
|
|
523
|
-
};
|
|
524
|
-
const onDisconnected = () => {
|
|
525
|
-
logger.info({
|
|
526
|
-
title: "Connection closed",
|
|
527
|
-
type: "system",
|
|
528
|
-
extra: {}
|
|
529
|
-
});
|
|
530
|
-
adapter.setConnected(false);
|
|
531
|
-
adapter.setConnecting(false);
|
|
532
|
-
socket.events.emitConnecting({ connecting: false });
|
|
533
|
-
socket.events.emitDisconnected();
|
|
534
|
-
socket.unstable_onDisconnectCallbacks.forEach((callback) => {
|
|
535
|
-
callback();
|
|
536
|
-
});
|
|
537
|
-
};
|
|
538
|
-
const onError = ({ error }) => {
|
|
539
|
-
logger.info({
|
|
540
|
-
title: "Error message",
|
|
541
|
-
type: "system",
|
|
542
|
-
extra: { error }
|
|
543
|
-
});
|
|
544
|
-
socket.unstable_onErrorCallbacks.forEach((callback) => {
|
|
545
|
-
callback({ error });
|
|
546
|
-
});
|
|
547
|
-
socket.events.emitError({ error });
|
|
548
|
-
};
|
|
549
|
-
const onEvent = ({ topic, data, extra }) => {
|
|
550
|
-
logger.info({
|
|
551
|
-
title: "New event message",
|
|
552
|
-
type: "system",
|
|
553
|
-
extra: {
|
|
554
|
-
topic,
|
|
555
|
-
data,
|
|
556
|
-
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;
|
|
557
489
|
}
|
|
490
|
+
const resolveDisconnected = () => {
|
|
491
|
+
resolve(true);
|
|
492
|
+
currentWebsocket.removeEventListener("close", resolveDisconnected);
|
|
493
|
+
};
|
|
494
|
+
currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
558
495
|
});
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
496
|
+
onDisconnect();
|
|
497
|
+
currentWebsocket.close(1e3);
|
|
498
|
+
clearTimers();
|
|
499
|
+
return promise;
|
|
500
|
+
};
|
|
501
|
+
const reconnect = async () => {
|
|
502
|
+
await onReconnect({
|
|
503
|
+
disconnect,
|
|
504
|
+
connect
|
|
567
505
|
});
|
|
568
|
-
|
|
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({
|
|
569
514
|
topic,
|
|
570
|
-
data:
|
|
571
|
-
|
|
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
|
|
572
539
|
});
|
|
573
540
|
};
|
|
574
|
-
const
|
|
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
|
+
});
|
|
575
550
|
return {
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
onReconnect,
|
|
582
|
-
onDisconnect,
|
|
583
|
-
onListen,
|
|
584
|
-
onEmit,
|
|
585
|
-
onEmitError,
|
|
586
|
-
onConnected,
|
|
587
|
-
onDisconnected,
|
|
588
|
-
onError,
|
|
589
|
-
onEvent
|
|
551
|
+
connect,
|
|
552
|
+
reconnect,
|
|
553
|
+
disconnect,
|
|
554
|
+
listen,
|
|
555
|
+
emit
|
|
590
556
|
};
|
|
591
|
-
};
|
|
557
|
+
});
|
|
592
558
|
//#endregion
|
|
593
|
-
//#region src/
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
emitterOptions;
|
|
607
|
-
getConnector;
|
|
608
|
-
connected = false;
|
|
609
|
-
connecting = false;
|
|
610
|
-
reconnectionAttempts = 0;
|
|
611
|
-
forceClosed = false;
|
|
612
|
-
listeners = /* @__PURE__ */ new Map();
|
|
613
|
-
listen;
|
|
614
|
-
emit;
|
|
615
|
-
connect;
|
|
616
|
-
reconnect;
|
|
617
|
-
disconnect;
|
|
618
|
-
constructor(options) {
|
|
619
|
-
this.options = options;
|
|
620
|
-
this.name = options.name;
|
|
621
|
-
this.queryParams = options.queryParams;
|
|
622
|
-
if (options.defaultConnected) this.setConnected(options.defaultConnected);
|
|
623
|
-
if (options.defaultConnecting) this.setConnecting(options.defaultConnecting);
|
|
624
|
-
if (options.defaultReconnectionAttempts) this.setReconnectionAttempts(options.defaultReconnectionAttempts);
|
|
625
|
-
if (options.defaultForceClosed) this.setForceClosed(options.defaultForceClosed);
|
|
626
|
-
}
|
|
627
|
-
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) {
|
|
628
572
|
this.socket = socket;
|
|
629
|
-
this.
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
this.
|
|
635
|
-
this.emit = emit;
|
|
636
|
-
this.connect = connect;
|
|
637
|
-
this.reconnect = reconnect;
|
|
638
|
-
this.disconnect = disconnect;
|
|
639
|
-
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;
|
|
640
579
|
}
|
|
641
|
-
|
|
642
|
-
|
|
643
|
-
return this;
|
|
580
|
+
/** Set adapter-specific emit options (e.g., acknowledgment, timeout). */
|
|
581
|
+
setOptions(options) {
|
|
582
|
+
return this.clone({ options });
|
|
644
583
|
}
|
|
645
|
-
|
|
646
|
-
|
|
647
|
-
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 });
|
|
648
597
|
}
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
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;
|
|
652
617
|
}
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
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);
|
|
656
642
|
}
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
643
|
+
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
|
|
644
|
+
return value !== value;
|
|
645
|
+
};
|
|
646
|
+
function EventEmitter() {
|
|
647
|
+
EventEmitter.init.call(this);
|
|
660
648
|
}
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
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);
|
|
664
658
|
}
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
this.unstable_queryParamsMapper = ((queryParams) => queryParamsMapper(queryParams, this.unstable_queryParamsMapperConfig));
|
|
674
|
-
return this;
|
|
675
|
-
};
|
|
676
|
-
removeListener = ({ topic, callback }) => {
|
|
677
|
-
const listenerGroup = this.listeners.get(topic);
|
|
678
|
-
if (listenerGroup) {
|
|
679
|
-
const unmount = listenerGroup.get(callback);
|
|
680
|
-
this.socket.events.emitListenerRemoveEvent({ topic });
|
|
681
|
-
listenerGroup.delete(callback);
|
|
682
|
-
unmount?.();
|
|
683
|
-
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;
|
|
684
667
|
}
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
extra
|
|
693
|
-
});
|
|
694
|
-
});
|
|
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;
|
|
673
|
+
}
|
|
674
|
+
this._maxListeners = this._maxListeners || void 0;
|
|
695
675
|
};
|
|
696
|
-
|
|
697
|
-
|
|
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;
|
|
698
679
|
return this;
|
|
699
680
|
};
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
return
|
|
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);
|
|
703
687
|
};
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
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;
|
|
707
712
|
};
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
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);
|
|
711
751
|
};
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
};
|
|
716
|
-
return this;
|
|
752
|
+
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
753
|
+
EventEmitter.prototype.prependListener = function prependListener(type, listener) {
|
|
754
|
+
return _addListener(this, type, listener, true);
|
|
717
755
|
};
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
/** istanbul ignore next */
|
|
725
|
-
if (!window?.WebSocket) return null;
|
|
726
|
-
} catch (error) {
|
|
727
|
-
return null;
|
|
728
|
-
}
|
|
729
|
-
class HyperFetchWebsocket extends WebSocket {
|
|
730
|
-
registeredHandlers = /* @__PURE__ */ new Map();
|
|
731
|
-
constructor(socketUrl, protocols) {
|
|
732
|
-
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);
|
|
733
762
|
}
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
removeEventListener = (type, listener, options) => {
|
|
743
|
-
super.removeEventListener(type, listener, options);
|
|
744
|
-
this.registeredHandlers.delete(listener);
|
|
745
|
-
};
|
|
746
|
-
clearListeners = () => {
|
|
747
|
-
this.registeredHandlers.forEach(({ type, listener, options }) => {
|
|
748
|
-
if (!options?.disableCleanup) this.removeEventListener(type, listener, options);
|
|
749
|
-
});
|
|
763
|
+
}
|
|
764
|
+
function _onceWrap(target, type, listener) {
|
|
765
|
+
var state = {
|
|
766
|
+
fired: false,
|
|
767
|
+
wrapFn: void 0,
|
|
768
|
+
target,
|
|
769
|
+
type,
|
|
770
|
+
listener
|
|
750
771
|
};
|
|
772
|
+
var wrapped = onceWrapper.bind(state);
|
|
773
|
+
wrapped.listener = listener;
|
|
774
|
+
state.wrapFn = wrapped;
|
|
775
|
+
return wrapped;
|
|
751
776
|
}
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
var parseMessageEvent = (event) => {
|
|
757
|
-
return {
|
|
758
|
-
...parseResponse(event.data),
|
|
759
|
-
event
|
|
777
|
+
EventEmitter.prototype.once = function once(type, listener) {
|
|
778
|
+
checkListener(listener);
|
|
779
|
+
this.on(type, _onceWrap(this, type, listener));
|
|
780
|
+
return this;
|
|
760
781
|
};
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
default: return "Unknown reason";
|
|
785
|
-
}
|
|
786
|
-
if ("data" in event) return JSON.stringify(event.data);
|
|
787
|
-
return "There was an socket error";
|
|
788
|
-
};
|
|
789
|
-
//#endregion
|
|
790
|
-
//#region src/adapter-websockets/websocket-adapter.ts
|
|
791
|
-
var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, logger, getQueryParams, onConnect, onReconnect, onDisconnect, onListen, onEmit, onConnected, onDisconnected, onError, onEvent }) => {
|
|
792
|
-
const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
|
|
793
|
-
let websocket;
|
|
794
|
-
let pingTimer;
|
|
795
|
-
let pongTimer;
|
|
796
|
-
let timeout;
|
|
797
|
-
const connect = async () => {
|
|
798
|
-
const url = getSocketUrl(socket.url, getQueryParams());
|
|
799
|
-
if (!onConnect()) return Promise.resolve(false);
|
|
800
|
-
clearTimeout(timeout);
|
|
801
|
-
websocket?.clearListeners();
|
|
802
|
-
websocket?.close(1e3);
|
|
803
|
-
const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
|
|
804
|
-
websocket = newWebsocket;
|
|
805
|
-
if (!newWebsocket) {
|
|
806
|
-
logger.error({
|
|
807
|
-
title: "Cannot connect to websocket",
|
|
808
|
-
type: "system",
|
|
809
|
-
extra: { websocket }
|
|
810
|
-
});
|
|
811
|
-
return Promise.resolve(false);
|
|
812
|
-
}
|
|
813
|
-
newWebsocket.clearListeners();
|
|
814
|
-
timeout = setTimeout(() => {
|
|
815
|
-
reconnect();
|
|
816
|
-
}, socket.reconnectTime);
|
|
817
|
-
/**
|
|
818
|
-
* Mount listeners
|
|
819
|
-
*/
|
|
820
|
-
newWebsocket.addEventListener("open", () => {
|
|
821
|
-
clearTimeout(timeout);
|
|
822
|
-
onConnected();
|
|
823
|
-
onHeartbeat();
|
|
824
|
-
});
|
|
825
|
-
newWebsocket.addEventListener("close", (event) => {
|
|
826
|
-
clearTimeout(timeout);
|
|
827
|
-
onDisconnected();
|
|
828
|
-
clearTimers();
|
|
829
|
-
const error = getSocketError(event);
|
|
830
|
-
onError({ error: new Error(error) });
|
|
831
|
-
if (event.code !== 1e3) timeout = setTimeout(() => {
|
|
832
|
-
reconnect();
|
|
833
|
-
}, socket.reconnectTime);
|
|
834
|
-
});
|
|
835
|
-
newWebsocket.addEventListener("message", (newEvent) => {
|
|
836
|
-
const { topic, data, event } = parseMessageEvent(newEvent);
|
|
837
|
-
onEvent({
|
|
838
|
-
topic,
|
|
839
|
-
data,
|
|
840
|
-
extra: event
|
|
841
|
-
});
|
|
842
|
-
onHeartbeat();
|
|
843
|
-
});
|
|
844
|
-
return new Promise((resolve) => {
|
|
845
|
-
if (newWebsocket.readyState === WebSocket.OPEN) {
|
|
846
|
-
resolve(true);
|
|
847
|
-
socket.adapter.setConnected(true);
|
|
848
|
-
socket.adapter.setConnecting(false);
|
|
849
|
-
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;
|
|
850
805
|
}
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
};
|
|
859
|
-
const resolveError = () => {
|
|
860
|
-
resolve(false);
|
|
861
|
-
newWebsocket.removeEventListener("error", resolveError);
|
|
862
|
-
};
|
|
863
|
-
newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
|
|
864
|
-
newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
865
|
-
newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
|
|
866
|
-
});
|
|
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;
|
|
867
813
|
};
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
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;
|
|
873
825
|
}
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
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);
|
|
881
833
|
}
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
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;
|
|
892
843
|
};
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
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);
|
|
898
854
|
};
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
clearTimeout(pongTimer);
|
|
855
|
+
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
|
856
|
+
return _listeners(this, type, false);
|
|
902
857
|
};
|
|
903
|
-
|
|
904
|
-
if (
|
|
905
|
-
|
|
906
|
-
topic,
|
|
907
|
-
data: payload
|
|
908
|
-
}));
|
|
909
|
-
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);
|
|
910
861
|
};
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
{
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
websocket?.close();
|
|
924
|
-
}, pongTimeout);
|
|
925
|
-
}, 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) : [];
|
|
926
874
|
};
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
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 });
|
|
931
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;
|
|
932
959
|
};
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
if (
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
socket.appManager.events.onOnline(() => {
|
|
940
|
-
if (autoConnect && !socket.adapter.connected) connect();
|
|
941
|
-
});
|
|
942
|
-
return {
|
|
943
|
-
connect,
|
|
944
|
-
reconnect,
|
|
945
|
-
disconnect,
|
|
946
|
-
listen,
|
|
947
|
-
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;
|
|
948
966
|
};
|
|
949
|
-
}
|
|
967
|
+
};
|
|
950
968
|
//#endregion
|
|
951
969
|
//#region src/socket/socket.ts
|
|
970
|
+
var import_events = /* @__PURE__ */ __toESM(require_events());
|
|
952
971
|
var Socket = class {
|
|
953
972
|
emitter = new import_events.default();
|
|
954
973
|
events = getSocketEvents(this.emitter);
|
|
@@ -1279,7 +1298,7 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
|
|
|
1279
1298
|
try {
|
|
1280
1299
|
/** istanbul ignore next */
|
|
1281
1300
|
if (!window?.EventSource) return null;
|
|
1282
|
-
} catch
|
|
1301
|
+
} catch {
|
|
1283
1302
|
return null;
|
|
1284
1303
|
}
|
|
1285
1304
|
class HyperFetchEventSource extends EventSource {
|
|
@@ -1324,6 +1343,7 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
|
|
|
1324
1343
|
};
|
|
1325
1344
|
//#endregion
|
|
1326
1345
|
//#region src/adapter-sse/sse-adapter.ts
|
|
1346
|
+
/** Create a preconfigured socket adapter for Server-Sent Events (EventSource) connections. */
|
|
1327
1347
|
var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, adapter, getQueryParams, onConnect, onReconnect, onDisconnect, onListen, onConnected, onDisconnected, onError, onEvent }) => {
|
|
1328
1348
|
let sse;
|
|
1329
1349
|
const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
|
|
@@ -1380,18 +1400,18 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1380
1400
|
if (!sse) {
|
|
1381
1401
|
adapter.setConnected(false);
|
|
1382
1402
|
adapter.setConnecting(false);
|
|
1383
|
-
return
|
|
1403
|
+
return true;
|
|
1384
1404
|
}
|
|
1385
1405
|
const currentSse = sse;
|
|
1386
1406
|
if (currentSse.readyState === EventSource.CLOSED) {
|
|
1387
1407
|
adapter.setConnected(false);
|
|
1388
1408
|
adapter.setConnecting(false);
|
|
1389
|
-
return
|
|
1409
|
+
return true;
|
|
1390
1410
|
}
|
|
1391
1411
|
onDisconnect();
|
|
1392
1412
|
currentSse.close();
|
|
1393
1413
|
onDisconnected();
|
|
1394
|
-
return
|
|
1414
|
+
return true;
|
|
1395
1415
|
};
|
|
1396
1416
|
const reconnect = () => {
|
|
1397
1417
|
onReconnect({
|
|
@@ -1480,7 +1500,7 @@ var createSocketRecursiveProxy = ({ socket, path, sdkKeys, options }) => {
|
|
|
1480
1500
|
const sdkPath = currentSdkKeys.join(".");
|
|
1481
1501
|
let pathSegment = key;
|
|
1482
1502
|
if (key.startsWith("$") && !LEAF_KEYS.has(key)) pathSegment = `:${key.slice(1)}`;
|
|
1483
|
-
else if (options?.camelCaseToKebabCase) pathSegment = key.
|
|
1503
|
+
else if (options?.camelCaseToKebabCase) pathSegment = key.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
|
|
1484
1504
|
if (LEAF_KEYS.has(key)) {
|
|
1485
1505
|
const topic = path.join("/");
|
|
1486
1506
|
let instance;
|