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