@hyper-fetch/sockets 8.2.0 → 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 +3 -1
- 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 +4 -3
- package/__tests__/features/sdk/sdk.configuration.spec.ts +3 -2
- package/__tests__/features/sdk/sdk.types.spec.ts +4 -4
- 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.map +1 -1
- package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -1
- 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 +1 -1
- package/dist/emitter/emitter.d.ts.map +1 -1
- package/dist/emitter/emitter.types.d.ts.map +1 -1
- package/dist/index.mjs +862 -862
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +1 -1
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/listener/listener.types.d.ts.map +1 -1
- package/dist/sdk/sdk.d.ts +2 -2
- 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 +7 -7
- package/src/adapter-sse/sse-adapter.utils.ts +4 -4
- package/src/adapter-websockets/websocket-adapter.ts +11 -11
- package/src/adapter-websockets/websocket-adapter.utils.ts +4 -4
- package/src/emitter/emitter.ts +5 -6
- package/src/emitter/emitter.types.ts +0 -1
- package/src/listener/listener.ts +4 -5
- package/src/listener/listener.types.ts +0 -1
- package/src/sdk/sdk.ts +9 -9
- 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,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
|
|
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
|
-
/**
|
|
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
|
-
|
|
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
|
-
|
|
341
|
-
|
|
342
|
-
return
|
|
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
|
-
|
|
349
|
-
|
|
350
|
-
this
|
|
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
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
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
|
-
|
|
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/
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
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
|
-
|
|
404
|
-
|
|
405
|
-
|
|
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
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
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
|
-
|
|
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.
|
|
436
|
-
|
|
437
|
-
var
|
|
438
|
-
const
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
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
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
socket.
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
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
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
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
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
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
|
-
|
|
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
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
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
|
|
508
|
-
if (
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
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
|
-
|
|
517
|
-
const
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
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
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
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
|
-
|
|
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:
|
|
589
|
-
|
|
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
|
|
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
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
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/
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
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.
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
this.
|
|
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
|
-
|
|
660
|
-
|
|
661
|
-
return this;
|
|
580
|
+
/** Set adapter-specific emit options (e.g., acknowledgment, timeout). */
|
|
581
|
+
setOptions(options) {
|
|
582
|
+
return this.clone({ options });
|
|
662
583
|
}
|
|
663
|
-
|
|
664
|
-
|
|
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
|
-
|
|
668
|
-
|
|
669
|
-
|
|
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
|
-
|
|
672
|
-
|
|
673
|
-
|
|
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
|
-
|
|
676
|
-
|
|
677
|
-
|
|
643
|
+
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
|
|
644
|
+
return value !== value;
|
|
645
|
+
};
|
|
646
|
+
function EventEmitter() {
|
|
647
|
+
EventEmitter.init.call(this);
|
|
678
648
|
}
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
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
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
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
|
-
|
|
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
|
-
|
|
715
|
-
|
|
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
|
-
|
|
719
|
-
|
|
720
|
-
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);
|
|
721
687
|
};
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
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
|
-
|
|
727
|
-
|
|
728
|
-
|
|
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
|
-
|
|
731
|
-
|
|
732
|
-
|
|
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
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
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
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
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
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
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
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
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
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
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
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
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
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
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
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
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
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
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
|
-
|
|
919
|
-
|
|
920
|
-
clearTimeout(pongTimer);
|
|
855
|
+
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
|
856
|
+
return _listeners(this, type, false);
|
|
921
857
|
};
|
|
922
|
-
|
|
923
|
-
if (
|
|
924
|
-
|
|
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
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
{
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
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
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
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
|
-
|
|
953
|
-
|
|
954
|
-
if (
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
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
|
|
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
|
|
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
|
|
1409
|
+
return true;
|
|
1410
1410
|
}
|
|
1411
1411
|
onDisconnect();
|
|
1412
1412
|
currentSse.close();
|
|
1413
1413
|
onDisconnected();
|
|
1414
|
-
return
|
|
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.
|
|
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;
|