@hyper-fetch/sockets 1.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 +7 -0
- package/README.md +76 -0
- package/dist/client/client.d.ts +28 -0
- package/dist/client/client.types.d.ts +30 -0
- package/dist/client/client.utils.d.ts +2 -0
- package/dist/client/index.d.ts +3 -0
- package/dist/emitter/emitter.d.ts +20 -0
- package/dist/emitter/emitter.types.d.ts +10 -0
- package/dist/emitter/index.d.ts +2 -0
- package/dist/index.cjs.js +2 -0
- package/dist/index.cjs.js.map +7 -0
- package/dist/index.d.ts +5 -0
- package/dist/index.esm.js +2 -0
- package/dist/index.esm.js.map +7 -0
- package/dist/listener/index.d.ts +2 -0
- package/dist/listener/listener.d.ts +14 -0
- package/dist/listener/listener.types.d.ts +6 -0
- package/dist/socket/index.d.ts +4 -0
- package/dist/socket/socket.d.ts +139 -0
- package/dist/socket/socket.events.d.ts +27 -0
- package/dist/socket/socket.types.d.ts +29 -0
- package/dist/socket/socket.utils.d.ts +16 -0
- package/dist/types/extract.types.d.ts +7 -0
- package/dist/types/index.d.ts +2 -0
- package/dist/types/tuple.types.d.ts +1 -0
- package/package.json +65 -0
- package/src/client/client.ts +230 -0
- package/src/client/client.types.ts +36 -0
- package/src/client/client.utils.ts +15 -0
- package/src/client/index.ts +3 -0
- package/src/emitter/emitter.ts +77 -0
- package/src/emitter/emitter.types.ts +15 -0
- package/src/emitter/index.ts +2 -0
- package/src/index.ts +5 -0
- package/src/listener/index.ts +2 -0
- package/src/listener/listener.ts +44 -0
- package/src/listener/listener.types.ts +8 -0
- package/src/socket/index.ts +4 -0
- package/src/socket/socket.events.ts +119 -0
- package/src/socket/socket.ts +235 -0
- package/src/socket/socket.types.ts +33 -0
- package/src/socket/socket.utils.ts +43 -0
- package/src/types/extract.types.ts +16 -0
- package/src/types/index.ts +2 -0
- package/src/types/tuple.types.ts +1 -0
- package/tsconfig.json +8 -0
package/src/index.ts
ADDED
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import { Socket } from "socket";
|
|
2
|
+
import { ListenerOptionsType } from "listener";
|
|
3
|
+
import { ListenerCallbackType, WebsocketClientType } from "client";
|
|
4
|
+
import { ExtractListenerOptionsType } from "types/extract.types";
|
|
5
|
+
|
|
6
|
+
export class Listener<ResponseType, ClientType extends WebsocketClientType> {
|
|
7
|
+
readonly name: string;
|
|
8
|
+
options?: ExtractListenerOptionsType<ClientType>;
|
|
9
|
+
|
|
10
|
+
constructor(
|
|
11
|
+
readonly socket: Socket<ClientType>,
|
|
12
|
+
readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<ClientType>>,
|
|
13
|
+
) {
|
|
14
|
+
const { name, options } = listenerOptions;
|
|
15
|
+
this.name = name;
|
|
16
|
+
this.options = options;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
setOptions(options: ExtractListenerOptionsType<ClientType>) {
|
|
20
|
+
return this.clone({ options });
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
clone(
|
|
24
|
+
config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<ClientType>>>,
|
|
25
|
+
): Listener<ResponseType, ClientType> {
|
|
26
|
+
return new Listener<ResponseType, ClientType>(this.socket, {
|
|
27
|
+
...this.listenerOptions,
|
|
28
|
+
...config,
|
|
29
|
+
name: this.name,
|
|
30
|
+
});
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
listen(callback: (data: ListenerCallbackType<ResponseType>) => void) {
|
|
34
|
+
const instance = this.clone();
|
|
35
|
+
|
|
36
|
+
this.socket.client.listen(instance, callback);
|
|
37
|
+
|
|
38
|
+
const removeListener = () => {
|
|
39
|
+
this.socket.client.removeListener(instance.name, callback);
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
return [removeListener, callback] as const;
|
|
43
|
+
}
|
|
44
|
+
}
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
import EventEmitter from "events";
|
|
2
|
+
|
|
3
|
+
import {
|
|
4
|
+
getErrorKey,
|
|
5
|
+
getCloseKey,
|
|
6
|
+
getConnectingKey,
|
|
7
|
+
getEmitterEventKey,
|
|
8
|
+
getListenerEventKey,
|
|
9
|
+
getOpenKey,
|
|
10
|
+
getReconnectingKey,
|
|
11
|
+
getReconnectingStopKey,
|
|
12
|
+
getListenerEventByNameKey,
|
|
13
|
+
getEmitterEventByNameKey,
|
|
14
|
+
getListenerRemoveKey,
|
|
15
|
+
getListenerRemoveByNameKey,
|
|
16
|
+
} from "socket";
|
|
17
|
+
import { EmitterInstance } from "emitter";
|
|
18
|
+
import { ListenerInstance } from "listener";
|
|
19
|
+
import { ExtractListenerResponseType } from "types/extract.types";
|
|
20
|
+
|
|
21
|
+
export const getSocketEvents = (eventEmitter: EventEmitter) => ({
|
|
22
|
+
emitError: <ResponseType = MessageEvent>(event: ResponseType): void => {
|
|
23
|
+
eventEmitter.emit(getErrorKey(), event);
|
|
24
|
+
},
|
|
25
|
+
emitOpen: (): void => {
|
|
26
|
+
eventEmitter.emit(getOpenKey());
|
|
27
|
+
},
|
|
28
|
+
emitClose: (): void => {
|
|
29
|
+
eventEmitter.emit(getCloseKey());
|
|
30
|
+
},
|
|
31
|
+
emitConnecting: (): void => {
|
|
32
|
+
eventEmitter.emit(getConnectingKey());
|
|
33
|
+
},
|
|
34
|
+
emitReconnecting: (attempts: number): void => {
|
|
35
|
+
eventEmitter.emit(getReconnectingKey(), attempts);
|
|
36
|
+
},
|
|
37
|
+
emitReconnectingStop: (attempts: number): void => {
|
|
38
|
+
eventEmitter.emit(getReconnectingStopKey(), attempts);
|
|
39
|
+
},
|
|
40
|
+
emitListenerEvent: <ResponseType = MessageEvent>(
|
|
41
|
+
name: string,
|
|
42
|
+
data: ResponseType,
|
|
43
|
+
event: MessageEvent<ResponseType>,
|
|
44
|
+
): void => {
|
|
45
|
+
eventEmitter.emit(getListenerEventKey(), data, event);
|
|
46
|
+
eventEmitter.emit(getListenerEventByNameKey(name), data, event);
|
|
47
|
+
},
|
|
48
|
+
emitListenerRemoveEvent: (name: string): void => {
|
|
49
|
+
eventEmitter.emit(getListenerRemoveKey(), name);
|
|
50
|
+
eventEmitter.emit(getListenerRemoveByNameKey(name));
|
|
51
|
+
},
|
|
52
|
+
emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType): void => {
|
|
53
|
+
eventEmitter.emit(getEmitterEventKey(), emitter);
|
|
54
|
+
eventEmitter.emit(getEmitterEventByNameKey(emitter.name), emitter);
|
|
55
|
+
},
|
|
56
|
+
|
|
57
|
+
onError: (callback: <ResponseType = MessageEvent>(event: ResponseType) => void): VoidFunction => {
|
|
58
|
+
eventEmitter.on(getErrorKey(), callback);
|
|
59
|
+
return () => eventEmitter.removeListener(getErrorKey(), callback);
|
|
60
|
+
},
|
|
61
|
+
onOpen: (callback: () => void): VoidFunction => {
|
|
62
|
+
eventEmitter.on(getOpenKey(), callback);
|
|
63
|
+
return () => eventEmitter.removeListener(getOpenKey(), callback);
|
|
64
|
+
},
|
|
65
|
+
onClose: (callback: () => void): VoidFunction => {
|
|
66
|
+
eventEmitter.on(getCloseKey(), callback);
|
|
67
|
+
return () => eventEmitter.removeListener(getCloseKey(), callback);
|
|
68
|
+
},
|
|
69
|
+
onConnecting: (callback: () => void): VoidFunction => {
|
|
70
|
+
eventEmitter.on(getConnectingKey(), callback);
|
|
71
|
+
return () => eventEmitter.removeListener(getConnectingKey(), callback);
|
|
72
|
+
},
|
|
73
|
+
onReconnecting: (callback: (attempts: number) => void): VoidFunction => {
|
|
74
|
+
eventEmitter.on(getReconnectingKey(), callback);
|
|
75
|
+
return () => eventEmitter.removeListener(getReconnectingKey(), callback);
|
|
76
|
+
},
|
|
77
|
+
onReconnectingStop: (callback: (attempts: number) => void): VoidFunction => {
|
|
78
|
+
eventEmitter.on(getReconnectingStopKey(), callback);
|
|
79
|
+
return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
|
|
80
|
+
},
|
|
81
|
+
onListenerEvent: <ResponseType = Event>(
|
|
82
|
+
callback: (data: ResponseType, event: MessageEvent<ResponseType>) => void,
|
|
83
|
+
): VoidFunction => {
|
|
84
|
+
eventEmitter.on(getListenerEventKey(), callback);
|
|
85
|
+
return () => eventEmitter.removeListener(getListenerEventKey(), callback);
|
|
86
|
+
},
|
|
87
|
+
onEmitterEvent: <EmitterType extends EmitterInstance>(callback: (emitter: EmitterType) => void): VoidFunction => {
|
|
88
|
+
eventEmitter.on(getEmitterEventKey(), callback);
|
|
89
|
+
return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
|
|
90
|
+
},
|
|
91
|
+
onListenerEventByName: <ListenerType extends ListenerInstance>(
|
|
92
|
+
listener: ListenerType,
|
|
93
|
+
callback: (
|
|
94
|
+
data: ExtractListenerResponseType<ListenerType>,
|
|
95
|
+
event: MessageEvent<ExtractListenerResponseType<ListenerType>>,
|
|
96
|
+
) => void,
|
|
97
|
+
): VoidFunction => {
|
|
98
|
+
eventEmitter.on(getListenerEventByNameKey(listener.name), callback);
|
|
99
|
+
return () => eventEmitter.removeListener(getListenerEventByNameKey(listener.name), callback);
|
|
100
|
+
},
|
|
101
|
+
onListenerRemove: (callback: (name: string) => void): VoidFunction => {
|
|
102
|
+
eventEmitter.on(getListenerRemoveKey(), callback);
|
|
103
|
+
return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
|
|
104
|
+
},
|
|
105
|
+
onListenerRemoveByName: <ListenerType extends ListenerInstance>(
|
|
106
|
+
listener: ListenerType,
|
|
107
|
+
callback: () => void,
|
|
108
|
+
): VoidFunction => {
|
|
109
|
+
eventEmitter.on(getListenerRemoveByNameKey(listener.name), callback);
|
|
110
|
+
return () => eventEmitter.removeListener(getListenerRemoveByNameKey(listener.name), callback);
|
|
111
|
+
},
|
|
112
|
+
onEmitterEventByName: <EmitterType extends EmitterInstance>(
|
|
113
|
+
emitter: EmitterType,
|
|
114
|
+
callback: (emitter: EmitterType) => void,
|
|
115
|
+
): VoidFunction => {
|
|
116
|
+
eventEmitter.on(getEmitterEventByNameKey(emitter.name), callback);
|
|
117
|
+
return () => eventEmitter.removeListener(getEmitterEventByNameKey(emitter.name), callback);
|
|
118
|
+
},
|
|
119
|
+
});
|
|
@@ -0,0 +1,235 @@
|
|
|
1
|
+
import EventEmitter from "events";
|
|
2
|
+
import {
|
|
3
|
+
stringifyQueryParams,
|
|
4
|
+
StringifyCallbackType,
|
|
5
|
+
QueryStringifyOptions,
|
|
6
|
+
LoggerManager,
|
|
7
|
+
SeverityType,
|
|
8
|
+
AppManager,
|
|
9
|
+
DateInterval,
|
|
10
|
+
ClientQueryParamsType,
|
|
11
|
+
} from "@hyper-fetch/core";
|
|
12
|
+
|
|
13
|
+
import {
|
|
14
|
+
SocketConfig,
|
|
15
|
+
ReconnectCallbackType,
|
|
16
|
+
ReconnectStopCallbackType,
|
|
17
|
+
OpenCallbackType,
|
|
18
|
+
CloseCallbackType,
|
|
19
|
+
MessageCallbackType,
|
|
20
|
+
SendCallbackType,
|
|
21
|
+
ErrorCallbackType,
|
|
22
|
+
getSocketEvents,
|
|
23
|
+
interceptListener,
|
|
24
|
+
interceptEmitter,
|
|
25
|
+
} from "socket";
|
|
26
|
+
import { WebsocketClientType, SocketClient } from "client";
|
|
27
|
+
import { Listener, ListenerOptionsType } from "listener";
|
|
28
|
+
import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
|
|
29
|
+
|
|
30
|
+
export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
|
|
31
|
+
public emitter = new EventEmitter();
|
|
32
|
+
public events = getSocketEvents(this.emitter);
|
|
33
|
+
|
|
34
|
+
url: string;
|
|
35
|
+
reconnect: number;
|
|
36
|
+
reconnectTime: number;
|
|
37
|
+
auth?: ClientQueryParamsType | string;
|
|
38
|
+
queryParams?: ClientQueryParamsType | string;
|
|
39
|
+
debug: boolean;
|
|
40
|
+
autoConnect: boolean;
|
|
41
|
+
|
|
42
|
+
// Callbacks
|
|
43
|
+
__onOpenCallbacks: OpenCallbackType<Socket<ClientType>, any>[] = [];
|
|
44
|
+
__onCloseCallbacks: CloseCallbackType<Socket<ClientType>, any>[] = [];
|
|
45
|
+
__onReconnectCallbacks: ReconnectCallbackType<Socket<ClientType>>[] = [];
|
|
46
|
+
__onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<ClientType>>[] = [];
|
|
47
|
+
__onMessageCallbacks: MessageCallbackType<Socket<ClientType>, any>[] = [];
|
|
48
|
+
__onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
|
|
49
|
+
__onErrorCallbacks: ErrorCallbackType<Socket<ClientType>, any>[] = [];
|
|
50
|
+
|
|
51
|
+
// Config
|
|
52
|
+
client: ClientType;
|
|
53
|
+
loggerManager = new LoggerManager(this);
|
|
54
|
+
appManager = new AppManager();
|
|
55
|
+
queryParamsConfig?: QueryStringifyOptions;
|
|
56
|
+
|
|
57
|
+
// Logger
|
|
58
|
+
logger = this.loggerManager.init("Socket");
|
|
59
|
+
|
|
60
|
+
/**
|
|
61
|
+
* Method to stringify query params from objects.
|
|
62
|
+
*/
|
|
63
|
+
queryParamsStringify: StringifyCallbackType = (queryParams) => {
|
|
64
|
+
return stringifyQueryParams(queryParams, this.queryParamsConfig);
|
|
65
|
+
};
|
|
66
|
+
|
|
67
|
+
constructor(public options: SocketConfig<ClientType>) {
|
|
68
|
+
const {
|
|
69
|
+
url,
|
|
70
|
+
auth,
|
|
71
|
+
client,
|
|
72
|
+
queryParams,
|
|
73
|
+
autoConnect,
|
|
74
|
+
reconnect,
|
|
75
|
+
reconnectTime,
|
|
76
|
+
queryParamsConfig,
|
|
77
|
+
queryParamsStringify,
|
|
78
|
+
} = this.options;
|
|
79
|
+
this.url = url;
|
|
80
|
+
this.auth = auth;
|
|
81
|
+
this.queryParams = queryParams;
|
|
82
|
+
this.debug = false;
|
|
83
|
+
this.autoConnect = autoConnect ?? true;
|
|
84
|
+
this.reconnect = reconnect ?? Infinity;
|
|
85
|
+
this.reconnectTime = reconnectTime ?? DateInterval.second * 2;
|
|
86
|
+
|
|
87
|
+
if (queryParamsConfig) {
|
|
88
|
+
this.queryParamsConfig = queryParamsConfig;
|
|
89
|
+
}
|
|
90
|
+
if (queryParamsStringify) {
|
|
91
|
+
this.queryParamsStringify = queryParamsStringify;
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
// Client must be initialized at the end
|
|
95
|
+
this.client = client || (new SocketClient(this) as unknown as ClientType);
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
/**
|
|
99
|
+
* This method enables the logger usage and display the logs in console
|
|
100
|
+
*/
|
|
101
|
+
setDebug = (debug: boolean) => {
|
|
102
|
+
this.debug = debug;
|
|
103
|
+
return this;
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
/**
|
|
107
|
+
* Set the logger severity of the messages displayed to the console
|
|
108
|
+
*/
|
|
109
|
+
setLoggerSeverity = (severity: SeverityType) => {
|
|
110
|
+
this.loggerManager.setSeverity(severity);
|
|
111
|
+
return this;
|
|
112
|
+
};
|
|
113
|
+
|
|
114
|
+
/**
|
|
115
|
+
* Set the new logger instance to the socket
|
|
116
|
+
*/
|
|
117
|
+
setLogger = (callback: (socket: Socket<ClientType>) => LoggerManager) => {
|
|
118
|
+
this.loggerManager = callback(this);
|
|
119
|
+
return this;
|
|
120
|
+
};
|
|
121
|
+
|
|
122
|
+
/**
|
|
123
|
+
* Callbacks
|
|
124
|
+
*/
|
|
125
|
+
|
|
126
|
+
/**
|
|
127
|
+
* Triggered when connection is opened
|
|
128
|
+
* @param callback
|
|
129
|
+
* @returns
|
|
130
|
+
*/
|
|
131
|
+
onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<ClientType>, Event>) {
|
|
132
|
+
this.__onOpenCallbacks.push(callback);
|
|
133
|
+
return this;
|
|
134
|
+
}
|
|
135
|
+
/**
|
|
136
|
+
* Triggered when connection is closed
|
|
137
|
+
* @param callback
|
|
138
|
+
* @returns
|
|
139
|
+
*/
|
|
140
|
+
onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<ClientType>, Event>) {
|
|
141
|
+
this.__onCloseCallbacks.push(callback);
|
|
142
|
+
return this;
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
/**
|
|
146
|
+
* Triggered when connection is getting reconnected
|
|
147
|
+
* @param callback
|
|
148
|
+
* @returns
|
|
149
|
+
*/
|
|
150
|
+
onReconnect(callback: ReconnectCallbackType<Socket<ClientType>>) {
|
|
151
|
+
this.__onReconnectCallbacks.push(callback);
|
|
152
|
+
return this;
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
/**
|
|
156
|
+
* Triggered when connection attempts are stopped
|
|
157
|
+
* @param callback
|
|
158
|
+
* @returns
|
|
159
|
+
*/
|
|
160
|
+
onReconnectStop(callback: ReconnectStopCallbackType<Socket<ClientType>>) {
|
|
161
|
+
this.__onReconnectStopCallbacks.push(callback);
|
|
162
|
+
return this;
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
/**
|
|
166
|
+
* Triggered when any message is received
|
|
167
|
+
* @param callback
|
|
168
|
+
* @returns
|
|
169
|
+
*/
|
|
170
|
+
onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<ClientType>, Event>) {
|
|
171
|
+
this.__onMessageCallbacks.push(callback);
|
|
172
|
+
return this;
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
/**
|
|
176
|
+
* Triggered when any event is emitted
|
|
177
|
+
* @param callback
|
|
178
|
+
* @returns
|
|
179
|
+
*/
|
|
180
|
+
onSend<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>) {
|
|
181
|
+
this.__onSendCallbacks.push(callback);
|
|
182
|
+
return this;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
/**
|
|
186
|
+
* Triggered when we receive error
|
|
187
|
+
* @param callback
|
|
188
|
+
* @returns
|
|
189
|
+
*/
|
|
190
|
+
onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<ClientType>, Event>) {
|
|
191
|
+
this.__onErrorCallbacks.push(callback);
|
|
192
|
+
return this;
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
/**
|
|
196
|
+
* ********************
|
|
197
|
+
* Interceptors
|
|
198
|
+
* ********************
|
|
199
|
+
*/
|
|
200
|
+
|
|
201
|
+
__modifySend = (emitter: EmitterInstance) => {
|
|
202
|
+
return interceptEmitter(this.__onSendCallbacks, emitter);
|
|
203
|
+
};
|
|
204
|
+
|
|
205
|
+
__modifyResponse = (response: MessageEvent) => {
|
|
206
|
+
return interceptListener(this.__onMessageCallbacks, response, this);
|
|
207
|
+
};
|
|
208
|
+
|
|
209
|
+
/**
|
|
210
|
+
* ********************
|
|
211
|
+
* Creators
|
|
212
|
+
* ********************
|
|
213
|
+
*/
|
|
214
|
+
|
|
215
|
+
/**
|
|
216
|
+
* Create event listener
|
|
217
|
+
* @param options
|
|
218
|
+
* @returns
|
|
219
|
+
*/
|
|
220
|
+
createListener = <ResponseType>(options: ListenerOptionsType<ClientType>) => {
|
|
221
|
+
return new Listener<ResponseType, ClientType>(this, options as any);
|
|
222
|
+
};
|
|
223
|
+
|
|
224
|
+
/**
|
|
225
|
+
* Create event emitter
|
|
226
|
+
* @param options
|
|
227
|
+
* @returns
|
|
228
|
+
*/
|
|
229
|
+
createEmitter = <RequestDataType, ResponseDataType = never>(options: EmitterOptionsType<ClientType>) => {
|
|
230
|
+
if ("isSSE" in this.options) {
|
|
231
|
+
throw new Error("Cannot create emitters for SSE client");
|
|
232
|
+
}
|
|
233
|
+
return new Emitter<RequestDataType, ResponseDataType, ClientType>(this, options as any);
|
|
234
|
+
};
|
|
235
|
+
}
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import { ClientQueryParamsType, QueryStringifyOptions, StringifyCallbackType } from "@hyper-fetch/core";
|
|
2
|
+
|
|
3
|
+
import { Socket } from "socket";
|
|
4
|
+
import { ServerSentEventsClientOptionsType, WebsocketClientOptionsType } from "client";
|
|
5
|
+
import { EmitterInstance } from "emitter";
|
|
6
|
+
|
|
7
|
+
export type SocketInstance = Socket<any>;
|
|
8
|
+
|
|
9
|
+
export type SocketConfigBaseType<SocketClientType> = {
|
|
10
|
+
url: string;
|
|
11
|
+
client?: SocketClientType;
|
|
12
|
+
auth?: ClientQueryParamsType;
|
|
13
|
+
queryParams?: ClientQueryParamsType | string;
|
|
14
|
+
reconnect?: number;
|
|
15
|
+
reconnectTime?: number;
|
|
16
|
+
autoConnect?: boolean;
|
|
17
|
+
queryParamsConfig?: QueryStringifyOptions;
|
|
18
|
+
queryParamsStringify?: StringifyCallbackType;
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
export type SocketConfig<SocketClientType> =
|
|
22
|
+
| (SocketConfigBaseType<SocketClientType> & { isSSE: true; clientOptions?: ServerSentEventsClientOptionsType })
|
|
23
|
+
| (SocketConfigBaseType<SocketClientType> & {
|
|
24
|
+
clientOptions?: WebsocketClientOptionsType;
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
28
|
+
export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
29
|
+
export type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
30
|
+
export type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
31
|
+
export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
|
|
32
|
+
export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
|
|
33
|
+
export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import { EmitterInstance } from "emitter";
|
|
2
|
+
import { MessageCallbackType, SendCallbackType, SocketInstance } from "./socket.types";
|
|
3
|
+
|
|
4
|
+
export const getErrorKey = () => "socket_error";
|
|
5
|
+
export const getOpenKey = () => "socket_open";
|
|
6
|
+
export const getCloseKey = () => "socket_close";
|
|
7
|
+
export const getConnectingKey = () => "socket_connecting";
|
|
8
|
+
export const getReconnectingKey = () => "socket_reconnecting";
|
|
9
|
+
export const getReconnectingStopKey = () => "socket_reconnecting_stop";
|
|
10
|
+
export const getListenerEventKey = () => `listener_event`;
|
|
11
|
+
export const getListenerRemoveKey = () => `listener_remove`;
|
|
12
|
+
export const getEmitterEventKey = () => `emitter_event`;
|
|
13
|
+
export const getListenerRemoveByNameKey = (event: string) => `${event}_listener_remove`;
|
|
14
|
+
export const getListenerEventByNameKey = (event: string) => `${event}_listener_event`;
|
|
15
|
+
export const getEmitterEventByNameKey = (event: string) => `${event}_emitter_event`;
|
|
16
|
+
|
|
17
|
+
export const interceptListener = <SocketType extends SocketInstance>(
|
|
18
|
+
interceptors: MessageCallbackType<SocketType, MessageEvent>[],
|
|
19
|
+
response: MessageEvent,
|
|
20
|
+
socket: SocketType,
|
|
21
|
+
) => {
|
|
22
|
+
let newResponse = response;
|
|
23
|
+
// eslint-disable-next-line no-restricted-syntax
|
|
24
|
+
for (const interceptor of interceptors) {
|
|
25
|
+
newResponse = interceptor(response, socket);
|
|
26
|
+
if (!newResponse) throw new Error("Listener modifier must return data");
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
return newResponse;
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
export const interceptEmitter = <EmitterType extends EmitterInstance>(
|
|
33
|
+
interceptors: SendCallbackType<EmitterType>[],
|
|
34
|
+
emitter: EmitterType,
|
|
35
|
+
) => {
|
|
36
|
+
let newEmitter = emitter;
|
|
37
|
+
// eslint-disable-next-line no-restricted-syntax
|
|
38
|
+
for (const interceptor of interceptors) {
|
|
39
|
+
newEmitter = interceptor(emitter) as EmitterType;
|
|
40
|
+
if (!newEmitter) throw new Error("Send modifier must return emitter");
|
|
41
|
+
}
|
|
42
|
+
return newEmitter;
|
|
43
|
+
};
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { WebsocketClientType } from "client";
|
|
2
|
+
import { Emitter } from "emitter";
|
|
3
|
+
import { Listener } from "listener";
|
|
4
|
+
|
|
5
|
+
// Emitter
|
|
6
|
+
|
|
7
|
+
export type ExtractEmitterOptionsType<T extends Record<keyof WebsocketClientType | string, any>> = T["emitterOptions"];
|
|
8
|
+
|
|
9
|
+
export type ExtractListenerOptionsType<T extends Record<keyof WebsocketClientType | string, any>> =
|
|
10
|
+
T["listenerOptions"];
|
|
11
|
+
|
|
12
|
+
// Listener
|
|
13
|
+
|
|
14
|
+
export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
|
|
15
|
+
|
|
16
|
+
export type ExtractListenerDataType<T> = T extends Emitter<infer D, any, any> ? D : never;
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
|