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