@hyper-fetch/sockets 6.0.1 → 7.0.1
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
|
@@ -0,0 +1,259 @@
|
|
|
1
|
+
/* eslint-disable @typescript-eslint/no-use-before-define */
|
|
2
|
+
import { QueryParamsType, stringifyQueryParams, Time } from "@hyper-fetch/core";
|
|
3
|
+
|
|
4
|
+
import { EmitterInstance } from "emitter";
|
|
5
|
+
import { ExtendListener, ListenerCallbackType, ListenerInstance } from "listener";
|
|
6
|
+
import { SocketData } from "adapter";
|
|
7
|
+
import { SocketAdapter } from "adapter/adapter";
|
|
8
|
+
import { WebsocketAdapterOptionsType } from "./websocket-adapter.types";
|
|
9
|
+
import { getWebsocketAdapter } from "./websocket-adapter.utils";
|
|
10
|
+
import { getSocketUrl, parseMessageEvent } from "../utils";
|
|
11
|
+
import { getSocketError } from "../utils/socket.errors";
|
|
12
|
+
import { Socket } from "socket";
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* -------------------------------------------
|
|
16
|
+
* Websocket
|
|
17
|
+
* -------------------------------------------
|
|
18
|
+
*/
|
|
19
|
+
|
|
20
|
+
export type WebsocketAdapterType = SocketAdapter<
|
|
21
|
+
MessageEvent<any>,
|
|
22
|
+
WebsocketAdapterOptionsType,
|
|
23
|
+
undefined,
|
|
24
|
+
undefined,
|
|
25
|
+
QueryParamsType | string,
|
|
26
|
+
typeof stringifyQueryParams
|
|
27
|
+
>;
|
|
28
|
+
|
|
29
|
+
export const WebsocketAdapter = (): WebsocketAdapterType =>
|
|
30
|
+
new SocketAdapter<
|
|
31
|
+
MessageEvent<any>,
|
|
32
|
+
WebsocketAdapterOptionsType,
|
|
33
|
+
undefined,
|
|
34
|
+
undefined,
|
|
35
|
+
QueryParamsType | string,
|
|
36
|
+
typeof stringifyQueryParams
|
|
37
|
+
>({
|
|
38
|
+
name: "websockets",
|
|
39
|
+
})
|
|
40
|
+
.setQueryParamsMapper(stringifyQueryParams)
|
|
41
|
+
.setConnector(
|
|
42
|
+
({
|
|
43
|
+
socket,
|
|
44
|
+
logger,
|
|
45
|
+
getQueryParams,
|
|
46
|
+
onConnect,
|
|
47
|
+
onReconnect,
|
|
48
|
+
onDisconnect,
|
|
49
|
+
onListen,
|
|
50
|
+
onEmit,
|
|
51
|
+
onConnected,
|
|
52
|
+
onDisconnected,
|
|
53
|
+
onError,
|
|
54
|
+
onEvent,
|
|
55
|
+
}) => {
|
|
56
|
+
const autoConnect =
|
|
57
|
+
typeof socket.adapter.adapterOptions?.autoConnect === "boolean"
|
|
58
|
+
? socket.adapter.adapterOptions?.autoConnect
|
|
59
|
+
: true;
|
|
60
|
+
|
|
61
|
+
let websocket: ReturnType<typeof getWebsocketAdapter> | undefined;
|
|
62
|
+
|
|
63
|
+
let pingTimer: ReturnType<typeof setTimeout> | undefined;
|
|
64
|
+
let pongTimer: ReturnType<typeof setTimeout> | undefined;
|
|
65
|
+
let timeout: ReturnType<typeof setTimeout> | undefined;
|
|
66
|
+
|
|
67
|
+
const connect = async (): Promise<boolean> => {
|
|
68
|
+
const url = getSocketUrl(socket.url, getQueryParams());
|
|
69
|
+
const enabled = onConnect();
|
|
70
|
+
if (!enabled) {
|
|
71
|
+
return Promise.resolve(false);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
clearTimeout(timeout);
|
|
75
|
+
websocket?.clearListeners();
|
|
76
|
+
websocket?.close(1000);
|
|
77
|
+
|
|
78
|
+
const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
|
|
79
|
+
websocket = newWebsocket;
|
|
80
|
+
|
|
81
|
+
// Make sure we picked good environment
|
|
82
|
+
if (!newWebsocket) {
|
|
83
|
+
logger.error({
|
|
84
|
+
title: "Cannot connect to websocket",
|
|
85
|
+
type: "system",
|
|
86
|
+
extra: {
|
|
87
|
+
websocket,
|
|
88
|
+
},
|
|
89
|
+
});
|
|
90
|
+
return Promise.resolve(false);
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
// Clear listeners
|
|
94
|
+
newWebsocket.clearListeners();
|
|
95
|
+
|
|
96
|
+
// Reconnection timeout
|
|
97
|
+
timeout = setTimeout(() => {
|
|
98
|
+
reconnect();
|
|
99
|
+
}, socket.reconnectTime);
|
|
100
|
+
|
|
101
|
+
/**
|
|
102
|
+
* Mount listeners
|
|
103
|
+
*/
|
|
104
|
+
|
|
105
|
+
newWebsocket.addEventListener("open", () => {
|
|
106
|
+
clearTimeout(timeout);
|
|
107
|
+
onConnected();
|
|
108
|
+
onHeartbeat();
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
newWebsocket.addEventListener("close", (event) => {
|
|
112
|
+
clearTimeout(timeout);
|
|
113
|
+
onDisconnected();
|
|
114
|
+
clearTimers();
|
|
115
|
+
const error = getSocketError(event);
|
|
116
|
+
onError({ error: new Error(error) });
|
|
117
|
+
|
|
118
|
+
// If close was not by calling disconnect method, reconnect
|
|
119
|
+
if (event.code !== 1000) {
|
|
120
|
+
timeout = setTimeout(() => {
|
|
121
|
+
reconnect();
|
|
122
|
+
}, socket.reconnectTime);
|
|
123
|
+
}
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
newWebsocket.addEventListener("message", (newEvent: MessageEvent<SocketData>) => {
|
|
127
|
+
const { topic, data, event } = parseMessageEvent(newEvent);
|
|
128
|
+
|
|
129
|
+
onEvent({ topic, data, extra: event });
|
|
130
|
+
onHeartbeat();
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
return new Promise((resolve) => {
|
|
134
|
+
if (newWebsocket.readyState === WebSocket.OPEN) {
|
|
135
|
+
resolve(true);
|
|
136
|
+
socket.adapter.setConnected(true);
|
|
137
|
+
socket.adapter.setConnecting(false);
|
|
138
|
+
return;
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// Promise lifecycle
|
|
142
|
+
const resolveConnected = () => {
|
|
143
|
+
resolve(true);
|
|
144
|
+
newWebsocket.removeEventListener("open", resolveConnected);
|
|
145
|
+
};
|
|
146
|
+
const resolveDisconnected = () => {
|
|
147
|
+
resolve(false);
|
|
148
|
+
newWebsocket.removeEventListener("close", resolveDisconnected);
|
|
149
|
+
};
|
|
150
|
+
const resolveError = () => {
|
|
151
|
+
resolve(false);
|
|
152
|
+
newWebsocket.removeEventListener("error", resolveError);
|
|
153
|
+
};
|
|
154
|
+
|
|
155
|
+
newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
|
|
156
|
+
newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
157
|
+
newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
|
|
158
|
+
});
|
|
159
|
+
};
|
|
160
|
+
|
|
161
|
+
const disconnect = async (): Promise<boolean> => {
|
|
162
|
+
if (!websocket) {
|
|
163
|
+
socket.adapter.setConnected(false);
|
|
164
|
+
socket.adapter.setConnecting(false);
|
|
165
|
+
return Promise.resolve(true);
|
|
166
|
+
}
|
|
167
|
+
const currentWebsocket = websocket;
|
|
168
|
+
const promise = new Promise<boolean>((resolve) => {
|
|
169
|
+
if (currentWebsocket.readyState === WebSocket.CLOSED) {
|
|
170
|
+
resolve(true);
|
|
171
|
+
socket.adapter.setConnected(false);
|
|
172
|
+
socket.adapter.setConnecting(false);
|
|
173
|
+
return;
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
const resolveDisconnected = () => {
|
|
177
|
+
resolve(true);
|
|
178
|
+
currentWebsocket.removeEventListener("close", resolveDisconnected);
|
|
179
|
+
};
|
|
180
|
+
currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
onDisconnect();
|
|
184
|
+
currentWebsocket.close(1000);
|
|
185
|
+
clearTimers();
|
|
186
|
+
|
|
187
|
+
return promise;
|
|
188
|
+
};
|
|
189
|
+
|
|
190
|
+
const reconnect = async () => {
|
|
191
|
+
await onReconnect({ disconnect, connect });
|
|
192
|
+
};
|
|
193
|
+
|
|
194
|
+
const clearTimers = () => {
|
|
195
|
+
clearTimeout(pingTimer);
|
|
196
|
+
clearTimeout(pongTimer);
|
|
197
|
+
};
|
|
198
|
+
|
|
199
|
+
const sendEventMessage = ({ topic, payload }: Pick<EmitterInstance, "topic" | "payload">) => {
|
|
200
|
+
if (!websocket) return false;
|
|
201
|
+
websocket!.send(JSON.stringify({ topic, data: payload }));
|
|
202
|
+
return true;
|
|
203
|
+
};
|
|
204
|
+
|
|
205
|
+
const onHeartbeat = () => {
|
|
206
|
+
const {
|
|
207
|
+
heartbeat = false,
|
|
208
|
+
pingTimeout = Time.SEC * 5,
|
|
209
|
+
pongTimeout = Time.SEC * 5,
|
|
210
|
+
heartbeatMessage = "heartbeat",
|
|
211
|
+
} = socket.adapter.adapterOptions ||
|
|
212
|
+
/* istanbul ignore next */
|
|
213
|
+
{};
|
|
214
|
+
|
|
215
|
+
if (socket.adapter.connecting || !heartbeat) return;
|
|
216
|
+
clearTimers();
|
|
217
|
+
pingTimer = setTimeout(() => {
|
|
218
|
+
sendEventMessage({ topic: "heartbeat", payload: heartbeatMessage });
|
|
219
|
+
pongTimer = setTimeout(() => {
|
|
220
|
+
// this should trigger reconnect
|
|
221
|
+
websocket?.close();
|
|
222
|
+
}, pongTimeout);
|
|
223
|
+
}, pingTimeout);
|
|
224
|
+
};
|
|
225
|
+
|
|
226
|
+
const listen = (
|
|
227
|
+
listener: ExtendListener<ListenerInstance, { socket: Socket<WebsocketAdapterType> }>,
|
|
228
|
+
callback: ListenerCallbackType<WebsocketAdapterType, any>,
|
|
229
|
+
) => {
|
|
230
|
+
return onListen({ listener, callback });
|
|
231
|
+
};
|
|
232
|
+
|
|
233
|
+
const emit = async (emitter: EmitterInstance) => {
|
|
234
|
+
const mappedEmitter = await onEmit({ emitter });
|
|
235
|
+
if (!mappedEmitter) return;
|
|
236
|
+
|
|
237
|
+
return sendEventMessage(mappedEmitter);
|
|
238
|
+
};
|
|
239
|
+
|
|
240
|
+
// Initialize
|
|
241
|
+
if (autoConnect) {
|
|
242
|
+
connect();
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
socket.appManager.events.onOnline(() => {
|
|
246
|
+
if (autoConnect && !socket.adapter.connected) {
|
|
247
|
+
connect();
|
|
248
|
+
}
|
|
249
|
+
});
|
|
250
|
+
|
|
251
|
+
return {
|
|
252
|
+
connect,
|
|
253
|
+
reconnect,
|
|
254
|
+
disconnect,
|
|
255
|
+
listen,
|
|
256
|
+
emit,
|
|
257
|
+
};
|
|
258
|
+
},
|
|
259
|
+
);
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
import { EmptyTypes } from "@hyper-fetch/core";
|
|
2
|
+
|
|
3
|
+
import { WebsocketAdapterOptionsType } from "./websocket-adapter.types";
|
|
4
|
+
|
|
5
|
+
export const getWebsocketAdapter = (url: string, adapterOptions: WebsocketAdapterOptionsType | EmptyTypes) => {
|
|
6
|
+
/** istanbul ignore next */
|
|
7
|
+
try {
|
|
8
|
+
/** istanbul ignore next */
|
|
9
|
+
if (!window?.WebSocket) return null;
|
|
10
|
+
} catch (error) {
|
|
11
|
+
return null;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
class HyperFetchWebsocket extends WebSocket {
|
|
15
|
+
public listeners: Map<
|
|
16
|
+
(...args: any[]) => any,
|
|
17
|
+
{ type: keyof WebSocketEventMap; listener: (...args: any[]) => void; options: any }
|
|
18
|
+
> = new Map();
|
|
19
|
+
|
|
20
|
+
// eslint-disable-next-line @typescript-eslint/no-useless-constructor
|
|
21
|
+
constructor(socketUrl: string, protocols?: string | string[]) {
|
|
22
|
+
super(socketUrl, protocols);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
addEventListener = <K extends keyof WebSocketEventMap>(
|
|
26
|
+
type: K,
|
|
27
|
+
listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
|
|
28
|
+
options?: boolean | (AddEventListenerOptions & { disableCleanup?: boolean }),
|
|
29
|
+
) => {
|
|
30
|
+
super.addEventListener(type, listener, options);
|
|
31
|
+
this.listeners.set(listener, { type, listener, options });
|
|
32
|
+
};
|
|
33
|
+
|
|
34
|
+
removeEventListener = <K extends keyof WebSocketEventMap>(
|
|
35
|
+
type: K,
|
|
36
|
+
listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
|
|
37
|
+
options?: boolean | EventListenerOptions,
|
|
38
|
+
) => {
|
|
39
|
+
super.removeEventListener(type, listener, options);
|
|
40
|
+
this.listeners.delete(listener);
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
clearListeners = () => {
|
|
44
|
+
this.listeners.forEach(({ type, listener, options }) => {
|
|
45
|
+
if (!options?.disableCleanup) {
|
|
46
|
+
this.removeEventListener(type, listener, options);
|
|
47
|
+
}
|
|
48
|
+
});
|
|
49
|
+
};
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
return new HyperFetchWebsocket(url, adapterOptions?.protocols);
|
|
53
|
+
};
|
package/src/emitter/emitter.ts
CHANGED
|
@@ -1,145 +1,103 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { ExtractRouteParams, ParamsType, PayloadMapperType, EmptyTypes } from "@hyper-fetch/core";
|
|
2
2
|
|
|
3
|
-
import {
|
|
4
|
-
import {
|
|
5
|
-
import {
|
|
6
|
-
import { ConnectMethodType } from "types";
|
|
3
|
+
import { SocketInstance } from "socket";
|
|
4
|
+
import { EmitMethodOptionsType, EmitterCloneOptionsType, EmitterOptionsType, EmitType } from "emitter";
|
|
5
|
+
import { ExtractAdapterEmitterOptionsType, ExtractSocketAdapterType } from "types";
|
|
7
6
|
|
|
8
7
|
export class Emitter<
|
|
9
8
|
Payload,
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
MappedData = void,
|
|
9
|
+
Topic extends string,
|
|
10
|
+
Socket extends SocketInstance,
|
|
11
|
+
HasPayload extends boolean = false,
|
|
14
12
|
HasParams extends boolean = false,
|
|
15
|
-
HasData extends boolean = false,
|
|
16
13
|
> {
|
|
17
|
-
readonly
|
|
14
|
+
readonly topic: Topic;
|
|
18
15
|
params?: ParamsType;
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
16
|
+
payload: Payload | undefined;
|
|
17
|
+
options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined;
|
|
18
|
+
/** @internal */
|
|
19
|
+
unstable_payloadMapper?: PayloadMapperType<any>;
|
|
23
20
|
|
|
24
21
|
constructor(
|
|
25
|
-
readonly socket: Socket
|
|
26
|
-
readonly emitterOptions: EmitterOptionsType<
|
|
27
|
-
|
|
28
|
-
|
|
22
|
+
readonly socket: Socket,
|
|
23
|
+
readonly emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>,
|
|
24
|
+
/**
|
|
25
|
+
* Used to recreate the emitter with the same state
|
|
26
|
+
* @internal
|
|
27
|
+
*/
|
|
28
|
+
snapshot?: Partial<Emitter<Payload, Topic, Socket, any, any>>,
|
|
29
29
|
) {
|
|
30
|
-
const {
|
|
30
|
+
const { topic, options } = emitterOptions;
|
|
31
31
|
|
|
32
|
-
this.
|
|
33
|
-
this.
|
|
34
|
-
this.
|
|
35
|
-
this.
|
|
36
|
-
this.params = json?.params;
|
|
32
|
+
this.topic = snapshot?.topic ?? topic;
|
|
33
|
+
this.payload = snapshot?.payload;
|
|
34
|
+
this.options = snapshot?.options ?? options;
|
|
35
|
+
this.params = snapshot?.params;
|
|
37
36
|
}
|
|
38
37
|
|
|
39
|
-
setOptions(options:
|
|
38
|
+
setOptions(options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined) {
|
|
40
39
|
return this.clone({ options });
|
|
41
40
|
}
|
|
42
41
|
|
|
43
|
-
|
|
44
|
-
return this.clone({
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
setData(data: Payload) {
|
|
48
|
-
if (this.dataMapper) {
|
|
49
|
-
return this.clone<MappedData, MappedData, HasParams, true>({ data: this.dataMapper(data) });
|
|
50
|
-
}
|
|
51
|
-
return this.clone<Payload, MappedData, HasParams, true>({ data });
|
|
52
|
-
}
|
|
53
|
-
|
|
54
|
-
setDataMapper = <MapperData>(mapper: (data: Payload) => MapperData) => {
|
|
55
|
-
return this.clone<Payload, MapperData>(undefined, mapper);
|
|
42
|
+
setPayload = <D extends Payload>(payload: D) => {
|
|
43
|
+
return this.clone<D, D extends EmptyTypes ? false : true, HasParams>({
|
|
44
|
+
payload,
|
|
45
|
+
});
|
|
56
46
|
};
|
|
57
47
|
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
48
|
+
setPayloadMapper = <DataMapper extends (payload: Payload) => any | Promise<any>>(payloadMapper: DataMapper) => {
|
|
49
|
+
const cloned = this.clone<Payload, HasPayload, HasParams>(undefined);
|
|
50
|
+
|
|
51
|
+
cloned.unstable_payloadMapper = payloadMapper;
|
|
61
52
|
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
* @param callback
|
|
65
|
-
*/
|
|
66
|
-
onData(callback: ConnectMethodType<AdapterType, Response>) {
|
|
67
|
-
this.connections.add(callback);
|
|
53
|
+
return cloned;
|
|
54
|
+
};
|
|
68
55
|
|
|
69
|
-
|
|
56
|
+
setParams(params: NonNullable<ExtractRouteParams<Topic>>) {
|
|
57
|
+
return this.clone<Payload, HasPayload, true>({ params });
|
|
70
58
|
}
|
|
71
59
|
|
|
72
|
-
private paramsMapper = (params: ParamsType | null | undefined):
|
|
73
|
-
let
|
|
60
|
+
private paramsMapper = (params: ParamsType | null | undefined): Topic => {
|
|
61
|
+
let topic = this.emitterOptions.topic as string;
|
|
74
62
|
if (params) {
|
|
75
63
|
Object.entries(params).forEach(([key, value]) => {
|
|
76
|
-
|
|
64
|
+
topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
|
|
77
65
|
});
|
|
78
66
|
}
|
|
79
67
|
|
|
80
|
-
return
|
|
68
|
+
return topic as Topic;
|
|
81
69
|
};
|
|
82
70
|
|
|
83
71
|
clone<
|
|
84
|
-
NewPayload = Payload,
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
Data extends boolean = HasData,
|
|
72
|
+
NewPayload extends Payload = Payload,
|
|
73
|
+
NewHasPayload extends boolean = HasPayload,
|
|
74
|
+
NewHasParams extends boolean = HasParams,
|
|
88
75
|
>(
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
const json: Partial<Emitter<NewPayload, Response, Endpoint, AdapterType, MapperData, Params, Data>> = {
|
|
93
|
-
timeout: this.timeout,
|
|
76
|
+
config?: EmitterCloneOptionsType<NewPayload, ParamsType, Topic, Socket>,
|
|
77
|
+
): Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams> {
|
|
78
|
+
const snapshot: Partial<Emitter<Payload, Topic, Socket, NewHasPayload, NewHasParams>> = {
|
|
94
79
|
options: this.options,
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
80
|
+
payload: this.payload as unknown as Payload,
|
|
81
|
+
...config,
|
|
82
|
+
params: config?.params || this.params,
|
|
83
|
+
topic: this.paramsMapper(config?.params || this.params),
|
|
99
84
|
};
|
|
100
|
-
const mapperFn = (mapper || this.dataMapper) as typeof mapper;
|
|
101
85
|
|
|
102
|
-
const newInstance = new Emitter<NewPayload,
|
|
86
|
+
const newInstance = new Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>(
|
|
103
87
|
this.socket,
|
|
104
88
|
this.emitterOptions,
|
|
105
|
-
|
|
106
|
-
mapperFn,
|
|
89
|
+
snapshot as Partial<Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>>,
|
|
107
90
|
);
|
|
108
|
-
|
|
91
|
+
|
|
92
|
+
newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
|
|
93
|
+
|
|
109
94
|
return newInstance;
|
|
110
95
|
}
|
|
111
96
|
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
|
|
116
|
-
return ack(response as any);
|
|
117
|
-
};
|
|
118
|
-
}
|
|
119
|
-
if (this.connections.size) {
|
|
120
|
-
return (response: { data: any; extra: any; error: any }) => {
|
|
121
|
-
this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
|
|
122
|
-
};
|
|
123
|
-
}
|
|
124
|
-
return undefined;
|
|
125
|
-
};
|
|
97
|
+
emit: EmitType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>> = (options = {}) => {
|
|
98
|
+
const typedOptions = options as EmitMethodOptionsType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>>;
|
|
99
|
+
const instance = this.clone<Payload, HasPayload, HasParams>(typedOptions);
|
|
126
100
|
|
|
127
|
-
|
|
128
|
-
data,
|
|
129
|
-
params,
|
|
130
|
-
options,
|
|
131
|
-
ack,
|
|
132
|
-
}: {
|
|
133
|
-
data?: Payload;
|
|
134
|
-
params?: ExtractRouteParams<Endpoint>;
|
|
135
|
-
options?: Partial<EmitterOptionsType<Endpoint, AdapterType>>;
|
|
136
|
-
ack?: EmitterAcknowledgeType<any, AdapterType>;
|
|
137
|
-
} = {}) => {
|
|
138
|
-
const instance = this.clone({ ...options, data, params });
|
|
139
|
-
|
|
140
|
-
const eventMessageId = getUniqueRequestId(instance.endpoint);
|
|
141
|
-
|
|
142
|
-
this.socket.adapter.emit(eventMessageId, instance, instance.getAck(ack));
|
|
143
|
-
return eventMessageId;
|
|
101
|
+
this.socket.adapter.emit(instance);
|
|
144
102
|
};
|
|
145
103
|
}
|