@hyper-fetch/sockets 4.0.2 → 5.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/README.md +0 -9
- package/dist/index.cjs.js +852 -1
- package/dist/index.cjs.js.map +4 -4
- package/dist/index.d.ts +264 -131
- package/dist/index.esm.js +832 -1
- package/dist/index.esm.js.map +4 -4
- package/package.json +2 -2
- package/src/adapter/adapter.bindings.ts +158 -0
- package/src/adapter/adapter.sse.ts +127 -0
- package/src/adapter/adapter.types.ts +83 -11
- package/src/adapter/adapter.utils.ts +12 -7
- package/src/adapter/adapter.websocket.ts +187 -0
- package/src/adapter/index.ts +3 -1
- package/src/emitter/emitter.ts +103 -30
- package/src/emitter/emitter.types.ts +63 -8
- package/src/listener/listener.ts +62 -21
- package/src/listener/listener.types.ts +23 -4
- package/src/socket/socket.events.ts +44 -32
- package/src/socket/socket.ts +29 -28
- package/src/socket/socket.types.ts +8 -13
- package/src/socket/socket.utils.ts +7 -7
- package/src/types/connect.types.ts +6 -0
- package/src/types/extract.types.ts +11 -12
- package/src/types/index.ts +1 -0
- package/src/adapter/adapter.ts +0 -238
|
@@ -9,17 +9,17 @@ import {
|
|
|
9
9
|
getOpenKey,
|
|
10
10
|
getReconnectingKey,
|
|
11
11
|
getReconnectingStopKey,
|
|
12
|
-
|
|
13
|
-
|
|
12
|
+
getListenerEventByEndpointKey,
|
|
13
|
+
getEmitterEventByEndpointKey,
|
|
14
14
|
getListenerRemoveKey,
|
|
15
|
-
|
|
15
|
+
getListenerRemoveByEndpointKey,
|
|
16
16
|
} from "socket";
|
|
17
17
|
import { EmitterInstance } from "emitter";
|
|
18
18
|
import { ListenerInstance } from "listener";
|
|
19
|
-
import {
|
|
19
|
+
import { ExtractSocketExtraType, SocketAdapterInstance } from "adapter";
|
|
20
20
|
|
|
21
|
-
export const getSocketEvents = (eventEmitter: EventEmitter) => ({
|
|
22
|
-
emitError: <ResponseType
|
|
21
|
+
export const getSocketEvents = <T extends SocketAdapterInstance>(eventEmitter: EventEmitter) => ({
|
|
22
|
+
emitError: <ResponseType>(event: ResponseType): void => {
|
|
23
23
|
eventEmitter.emit(getErrorKey(), event);
|
|
24
24
|
},
|
|
25
25
|
emitOpen: (): void => {
|
|
@@ -37,24 +37,23 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
|
|
|
37
37
|
emitReconnectingStop: (attempts: number): void => {
|
|
38
38
|
eventEmitter.emit(getReconnectingStopKey(), attempts);
|
|
39
39
|
},
|
|
40
|
-
emitListenerEvent: <ResponseType
|
|
41
|
-
|
|
42
|
-
data: ResponseType,
|
|
43
|
-
event: MessageEvent<ResponseType>,
|
|
40
|
+
emitListenerEvent: <ResponseType>(
|
|
41
|
+
endpoint: string,
|
|
42
|
+
{ data, extra }: { data: ResponseType; extra: ExtractSocketExtraType<T> },
|
|
44
43
|
): void => {
|
|
45
|
-
eventEmitter.emit(getListenerEventKey(), data,
|
|
46
|
-
eventEmitter.emit(
|
|
44
|
+
eventEmitter.emit(getListenerEventKey(), { endpoint, data, extra });
|
|
45
|
+
eventEmitter.emit(getListenerEventByEndpointKey(endpoint), { endpoint, data, extra });
|
|
47
46
|
},
|
|
48
|
-
emitListenerRemoveEvent: (
|
|
49
|
-
eventEmitter.emit(getListenerRemoveKey(),
|
|
50
|
-
eventEmitter.emit(
|
|
47
|
+
emitListenerRemoveEvent: (endpoint: string): void => {
|
|
48
|
+
eventEmitter.emit(getListenerRemoveKey(), endpoint);
|
|
49
|
+
eventEmitter.emit(getListenerRemoveByEndpointKey(endpoint));
|
|
51
50
|
},
|
|
52
51
|
emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType): void => {
|
|
53
52
|
eventEmitter.emit(getEmitterEventKey(), emitter);
|
|
54
|
-
eventEmitter.emit(
|
|
53
|
+
eventEmitter.emit(getEmitterEventByEndpointKey(emitter.endpoint), emitter);
|
|
55
54
|
},
|
|
56
55
|
|
|
57
|
-
onError: (callback: <ResponseType
|
|
56
|
+
onError: (callback: <ResponseType>(event: ResponseType) => void): VoidFunction => {
|
|
58
57
|
eventEmitter.on(getErrorKey(), callback);
|
|
59
58
|
return () => eventEmitter.removeListener(getErrorKey(), callback);
|
|
60
59
|
},
|
|
@@ -79,7 +78,15 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
|
|
|
79
78
|
return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
|
|
80
79
|
},
|
|
81
80
|
onListenerEvent: <ResponseType = Event>(
|
|
82
|
-
callback: (
|
|
81
|
+
callback: ({
|
|
82
|
+
endpoint,
|
|
83
|
+
data,
|
|
84
|
+
extra,
|
|
85
|
+
}: {
|
|
86
|
+
endpoint: string;
|
|
87
|
+
data: ResponseType;
|
|
88
|
+
extra: ExtractSocketExtraType<T>;
|
|
89
|
+
}) => void,
|
|
83
90
|
): VoidFunction => {
|
|
84
91
|
eventEmitter.on(getListenerEventKey(), callback);
|
|
85
92
|
return () => eventEmitter.removeListener(getListenerEventKey(), callback);
|
|
@@ -88,32 +95,37 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
|
|
|
88
95
|
eventEmitter.on(getEmitterEventKey(), callback);
|
|
89
96
|
return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
|
|
90
97
|
},
|
|
91
|
-
|
|
98
|
+
onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(
|
|
92
99
|
listener: ListenerType,
|
|
93
|
-
callback: (
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
100
|
+
callback: ({
|
|
101
|
+
endpoint,
|
|
102
|
+
data,
|
|
103
|
+
extra,
|
|
104
|
+
}: {
|
|
105
|
+
endpoint: string;
|
|
106
|
+
data: ResponseType;
|
|
107
|
+
extra: ExtractSocketExtraType<T>;
|
|
108
|
+
}) => void,
|
|
97
109
|
): VoidFunction => {
|
|
98
|
-
eventEmitter.on(
|
|
99
|
-
return () => eventEmitter.removeListener(
|
|
110
|
+
eventEmitter.on(getListenerEventByEndpointKey(listener.endpoint), callback);
|
|
111
|
+
return () => eventEmitter.removeListener(getListenerEventByEndpointKey(listener.endpoint), callback);
|
|
100
112
|
},
|
|
101
|
-
onListenerRemove: (callback: (
|
|
113
|
+
onListenerRemove: (callback: (endpoint: string) => void): VoidFunction => {
|
|
102
114
|
eventEmitter.on(getListenerRemoveKey(), callback);
|
|
103
115
|
return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
|
|
104
116
|
},
|
|
105
|
-
|
|
117
|
+
onListenerRemoveByEndpoint: <ListenerType extends ListenerInstance>(
|
|
106
118
|
listener: ListenerType,
|
|
107
119
|
callback: () => void,
|
|
108
120
|
): VoidFunction => {
|
|
109
|
-
eventEmitter.on(
|
|
110
|
-
return () => eventEmitter.removeListener(
|
|
121
|
+
eventEmitter.on(getListenerRemoveByEndpointKey(listener.endpoint), callback);
|
|
122
|
+
return () => eventEmitter.removeListener(getListenerRemoveByEndpointKey(listener.endpoint), callback);
|
|
111
123
|
},
|
|
112
|
-
|
|
124
|
+
onEmitterEventByEndpoint: <EmitterType extends EmitterInstance>(
|
|
113
125
|
emitter: EmitterType,
|
|
114
126
|
callback: (emitter: EmitterType) => void,
|
|
115
127
|
): VoidFunction => {
|
|
116
|
-
eventEmitter.on(
|
|
117
|
-
return () => eventEmitter.removeListener(
|
|
128
|
+
eventEmitter.on(getEmitterEventByEndpointKey(emitter.endpoint), callback);
|
|
129
|
+
return () => eventEmitter.removeListener(getEmitterEventByEndpointKey(emitter.endpoint), callback);
|
|
118
130
|
},
|
|
119
131
|
});
|
package/src/socket/socket.ts
CHANGED
|
@@ -11,7 +11,7 @@ import {
|
|
|
11
11
|
} from "@hyper-fetch/core";
|
|
12
12
|
|
|
13
13
|
import {
|
|
14
|
-
|
|
14
|
+
SocketOptionsType,
|
|
15
15
|
ReconnectCallbackType,
|
|
16
16
|
ReconnectStopCallbackType,
|
|
17
17
|
OpenCallbackType,
|
|
@@ -23,11 +23,11 @@ import {
|
|
|
23
23
|
interceptListener,
|
|
24
24
|
interceptEmitter,
|
|
25
25
|
} from "socket";
|
|
26
|
-
import { AdapterType, SocketAdapter } from "adapter";
|
|
27
26
|
import { Listener, ListenerOptionsType } from "listener";
|
|
28
27
|
import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
|
|
28
|
+
import { ExtractSocketExtraType, SocketAdapterInstance, WebsocketAdapterType, websocketAdapter } from "adapter";
|
|
29
29
|
|
|
30
|
-
export class Socket<
|
|
30
|
+
export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
|
|
31
31
|
public emitter = new EventEmitter();
|
|
32
32
|
public events = getSocketEvents(this.emitter);
|
|
33
33
|
|
|
@@ -40,16 +40,16 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
40
40
|
autoConnect: boolean;
|
|
41
41
|
|
|
42
42
|
// Callbacks
|
|
43
|
-
__onOpenCallbacks: OpenCallbackType<Socket<
|
|
44
|
-
__onCloseCallbacks: CloseCallbackType<Socket<
|
|
45
|
-
__onReconnectCallbacks: ReconnectCallbackType<Socket<
|
|
46
|
-
__onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<
|
|
47
|
-
__onMessageCallbacks: MessageCallbackType<Socket<
|
|
43
|
+
__onOpenCallbacks: OpenCallbackType<Socket<AdapterType>>[] = [];
|
|
44
|
+
__onCloseCallbacks: CloseCallbackType<Socket<AdapterType>>[] = [];
|
|
45
|
+
__onReconnectCallbacks: ReconnectCallbackType<Socket<AdapterType>>[] = [];
|
|
46
|
+
__onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<AdapterType>>[] = [];
|
|
47
|
+
__onMessageCallbacks: MessageCallbackType<Socket<AdapterType>, any>[] = [];
|
|
48
48
|
__onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
|
|
49
|
-
__onErrorCallbacks: ErrorCallbackType<Socket<
|
|
49
|
+
__onErrorCallbacks: ErrorCallbackType<Socket<AdapterType>, any>[] = [];
|
|
50
50
|
|
|
51
51
|
// Config
|
|
52
|
-
adapter:
|
|
52
|
+
adapter: ReturnType<AdapterType>;
|
|
53
53
|
loggerManager = new LoggerManager(this);
|
|
54
54
|
appManager = new AppManager();
|
|
55
55
|
queryParamsConfig?: QueryStringifyOptionsType;
|
|
@@ -64,7 +64,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
64
64
|
return stringifyQueryParams(queryParams, this.queryParamsConfig);
|
|
65
65
|
};
|
|
66
66
|
|
|
67
|
-
constructor(public options:
|
|
67
|
+
constructor(public options: SocketOptionsType<AdapterType>) {
|
|
68
68
|
const {
|
|
69
69
|
url,
|
|
70
70
|
auth,
|
|
@@ -92,7 +92,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
92
92
|
}
|
|
93
93
|
|
|
94
94
|
// Adapter must be initialized at the end
|
|
95
|
-
this.adapter = adapter
|
|
95
|
+
this.adapter = (adapter ? adapter(this) : websocketAdapter(this)) as unknown as ReturnType<AdapterType>;
|
|
96
96
|
}
|
|
97
97
|
|
|
98
98
|
/**
|
|
@@ -114,7 +114,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
114
114
|
/**
|
|
115
115
|
* Set the new logger instance to the socket
|
|
116
116
|
*/
|
|
117
|
-
setLogger = (callback: (socket: Socket<
|
|
117
|
+
setLogger = (callback: (socket: Socket<AdapterType>) => LoggerManager) => {
|
|
118
118
|
this.loggerManager = callback(this);
|
|
119
119
|
return this;
|
|
120
120
|
};
|
|
@@ -146,7 +146,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
146
146
|
* @param callback
|
|
147
147
|
* @returns
|
|
148
148
|
*/
|
|
149
|
-
onOpen
|
|
149
|
+
onOpen(callback: OpenCallbackType<Socket<AdapterType>>) {
|
|
150
150
|
this.__onOpenCallbacks.push(callback);
|
|
151
151
|
return this;
|
|
152
152
|
}
|
|
@@ -155,7 +155,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
155
155
|
* @param callback
|
|
156
156
|
* @returns
|
|
157
157
|
*/
|
|
158
|
-
onClose
|
|
158
|
+
onClose(callback: CloseCallbackType<Socket<AdapterType>>) {
|
|
159
159
|
this.__onCloseCallbacks.push(callback);
|
|
160
160
|
return this;
|
|
161
161
|
}
|
|
@@ -165,7 +165,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
165
165
|
* @param callback
|
|
166
166
|
* @returns
|
|
167
167
|
*/
|
|
168
|
-
onReconnect(callback: ReconnectCallbackType<Socket<
|
|
168
|
+
onReconnect(callback: ReconnectCallbackType<Socket<AdapterType>>) {
|
|
169
169
|
this.__onReconnectCallbacks.push(callback);
|
|
170
170
|
return this;
|
|
171
171
|
}
|
|
@@ -175,7 +175,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
175
175
|
* @param callback
|
|
176
176
|
* @returns
|
|
177
177
|
*/
|
|
178
|
-
onReconnectStop(callback: ReconnectStopCallbackType<Socket<
|
|
178
|
+
onReconnectStop(callback: ReconnectStopCallbackType<Socket<AdapterType>>) {
|
|
179
179
|
this.__onReconnectStopCallbacks.push(callback);
|
|
180
180
|
return this;
|
|
181
181
|
}
|
|
@@ -185,7 +185,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
185
185
|
* @param callback
|
|
186
186
|
* @returns
|
|
187
187
|
*/
|
|
188
|
-
onMessage<Event =
|
|
188
|
+
onMessage<Event = ExtractSocketExtraType<AdapterType>>(callback: MessageCallbackType<Socket<AdapterType>, Event>) {
|
|
189
189
|
this.__onMessageCallbacks.push(callback);
|
|
190
190
|
return this;
|
|
191
191
|
}
|
|
@@ -205,7 +205,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
205
205
|
* @param callback
|
|
206
206
|
* @returns
|
|
207
207
|
*/
|
|
208
|
-
onError<Event =
|
|
208
|
+
onError<Event = ExtractSocketExtraType<AdapterType>>(callback: ErrorCallbackType<Socket<AdapterType>, Event>) {
|
|
209
209
|
this.__onErrorCallbacks.push(callback);
|
|
210
210
|
return this;
|
|
211
211
|
}
|
|
@@ -220,8 +220,8 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
220
220
|
return interceptEmitter(this.__onSendCallbacks, emitter);
|
|
221
221
|
};
|
|
222
222
|
|
|
223
|
-
__modifyResponse = (
|
|
224
|
-
return interceptListener(this.__onMessageCallbacks,
|
|
223
|
+
__modifyResponse = (data: { data: any; extra: ExtractSocketExtraType<AdapterType> }) => {
|
|
224
|
+
return interceptListener(this.__onMessageCallbacks, data, this);
|
|
225
225
|
};
|
|
226
226
|
|
|
227
227
|
/**
|
|
@@ -235,8 +235,10 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
235
235
|
* @param options
|
|
236
236
|
* @returns
|
|
237
237
|
*/
|
|
238
|
-
createListener = <Response>(
|
|
239
|
-
return
|
|
238
|
+
createListener = <Response>() => {
|
|
239
|
+
return <Endpoint extends string>(options: ListenerOptionsType<Endpoint, AdapterType>) => {
|
|
240
|
+
return new Listener<Response, Endpoint, AdapterType>(this, options);
|
|
241
|
+
};
|
|
240
242
|
};
|
|
241
243
|
|
|
242
244
|
/**
|
|
@@ -244,10 +246,9 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
|
|
|
244
246
|
* @param options
|
|
245
247
|
* @returns
|
|
246
248
|
*/
|
|
247
|
-
createEmitter = <Payload, Response = never>(
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
}
|
|
251
|
-
return new Emitter<Payload, Response, Adapter>(this, options as any);
|
|
249
|
+
createEmitter = <Payload, Response = never>() => {
|
|
250
|
+
return <Endpoint extends string>(options: EmitterOptionsType<Endpoint, AdapterType>) => {
|
|
251
|
+
return new Emitter<Payload, Response, Endpoint, AdapterType>(this, options);
|
|
252
|
+
};
|
|
252
253
|
};
|
|
253
254
|
}
|
|
@@ -1,33 +1,28 @@
|
|
|
1
1
|
import { QueryParamsType, QueryStringifyOptionsType, StringifyCallbackType } from "@hyper-fetch/core";
|
|
2
2
|
|
|
3
3
|
import { Socket } from "socket";
|
|
4
|
-
import {
|
|
4
|
+
import { ExtractSocketOptionsType, SocketAdapterInstance } from "adapter";
|
|
5
5
|
import { EmitterInstance } from "emitter";
|
|
6
6
|
|
|
7
|
-
export type SocketInstance = Socket<
|
|
7
|
+
export type SocketInstance = Socket<SocketAdapterInstance>;
|
|
8
8
|
|
|
9
|
-
export type SocketOptionsType<
|
|
9
|
+
export type SocketOptionsType<AdapterType extends SocketAdapterInstance> = {
|
|
10
10
|
url: string;
|
|
11
|
-
adapter?:
|
|
11
|
+
adapter?: AdapterType;
|
|
12
12
|
auth?: QueryParamsType;
|
|
13
|
-
queryParams?: QueryParamsType | string;
|
|
14
13
|
reconnect?: number;
|
|
15
14
|
reconnectTime?: number;
|
|
15
|
+
queryParams?: QueryParamsType | string;
|
|
16
16
|
autoConnect?: boolean;
|
|
17
17
|
queryParamsConfig?: QueryStringifyOptionsType;
|
|
18
18
|
queryParamsStringify?: StringifyCallbackType;
|
|
19
|
+
adapterOptions?: ExtractSocketOptionsType<AdapterType>;
|
|
19
20
|
};
|
|
20
21
|
|
|
21
|
-
export type SocketAdapterOptionsType<SocketAdapterType> =
|
|
22
|
-
| (SocketOptionsType<SocketAdapterType> & { isSSE: true; adapterOptions?: SSEAdapterOptionsType })
|
|
23
|
-
| (SocketOptionsType<SocketAdapterType> & {
|
|
24
|
-
adapterOptions?: WSAdapterOptionsType;
|
|
25
|
-
});
|
|
26
|
-
|
|
27
22
|
export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
28
23
|
export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
29
|
-
export type OpenCallbackType<SocketType extends SocketInstance
|
|
30
|
-
export type CloseCallbackType<SocketType extends SocketInstance
|
|
24
|
+
export type OpenCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
25
|
+
export type CloseCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
31
26
|
export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
|
|
32
27
|
export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
|
|
33
28
|
export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
@@ -10,19 +10,19 @@ export const getReconnectingStopKey = () => "socket_reconnecting_stop";
|
|
|
10
10
|
export const getListenerEventKey = () => `listener_event`;
|
|
11
11
|
export const getListenerRemoveKey = () => `listener_remove`;
|
|
12
12
|
export const getEmitterEventKey = () => `emitter_event`;
|
|
13
|
-
export const
|
|
14
|
-
export const
|
|
15
|
-
export const
|
|
13
|
+
export const getListenerRemoveByEndpointKey = (event: string) => `${event}_listener_remove`;
|
|
14
|
+
export const getListenerEventByEndpointKey = (event: string) => `${event}_listener_event`;
|
|
15
|
+
export const getEmitterEventByEndpointKey = (event: string) => `${event}_emitter_event`;
|
|
16
16
|
|
|
17
17
|
export const interceptListener = <Socket extends SocketInstance>(
|
|
18
|
-
interceptors: MessageCallbackType<Socket,
|
|
19
|
-
|
|
18
|
+
interceptors: MessageCallbackType<Socket, any>[],
|
|
19
|
+
data: { data: any; extra: any },
|
|
20
20
|
socket: Socket,
|
|
21
21
|
) => {
|
|
22
|
-
let newResponse =
|
|
22
|
+
let newResponse = data;
|
|
23
23
|
// eslint-disable-next-line no-restricted-syntax
|
|
24
24
|
for (const interceptor of interceptors) {
|
|
25
|
-
newResponse = interceptor(
|
|
25
|
+
newResponse = interceptor(data, socket);
|
|
26
26
|
if (!newResponse) throw new Error("Listener modifier must return data");
|
|
27
27
|
}
|
|
28
28
|
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import { ListenerCallbackType, SocketAdapterInstance } from "adapter";
|
|
2
|
+
|
|
3
|
+
export type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (
|
|
4
|
+
response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0],
|
|
5
|
+
unsubscribe: () => void,
|
|
6
|
+
) => void;
|
|
@@ -1,20 +1,19 @@
|
|
|
1
|
-
import { AdapterType } from "adapter";
|
|
2
1
|
import { Emitter } from "emitter";
|
|
3
2
|
import { Listener } from "listener";
|
|
4
3
|
|
|
5
|
-
// Adapter
|
|
6
|
-
|
|
7
|
-
export type ExtractEmitterOptionsType<E extends Record<keyof AdapterType | string, any>> = E["emitterOptions"];
|
|
8
|
-
export type ExtractListenerOptionsType<E extends Record<keyof AdapterType | string, any>> = E["listenerOptions"];
|
|
9
|
-
|
|
10
4
|
// Emitter
|
|
11
5
|
|
|
12
|
-
export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any> ? P : never;
|
|
13
|
-
export type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any> ? R : never;
|
|
14
|
-
export type
|
|
15
|
-
export type
|
|
6
|
+
export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any, any, any> ? P : never;
|
|
7
|
+
export type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any, any, any, any> ? R : never;
|
|
8
|
+
export type ExtractEmitterEndpointType<E> = E extends Emitter<any, any, infer A, any, any, any, any> ? A : never;
|
|
9
|
+
export type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, any, infer A, any, any, any> ? A : never;
|
|
10
|
+
export type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, any, infer M, any, any> ? M : never;
|
|
11
|
+
export type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, any, infer M, any> ? M : never;
|
|
12
|
+
export type ExtractEmitterHasDataType<E> = E extends Emitter<any, any, any, any, any, any, infer D> ? D : never;
|
|
16
13
|
|
|
17
14
|
// Listener
|
|
18
15
|
|
|
19
|
-
export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
|
|
20
|
-
export type
|
|
16
|
+
export type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
|
|
17
|
+
export type ExtractListenerEndpointType<E> = E extends Listener<any, infer A, any, any> ? A : never;
|
|
18
|
+
export type ExtractListenerAdapterType<E> = E extends Listener<any, any, infer A, any> ? A : never;
|
|
19
|
+
export type ExtractListenerHasParams<E> = E extends Listener<any, any, any, infer P> ? P : never;
|
package/src/types/index.ts
CHANGED
package/src/adapter/adapter.ts
DELETED
|
@@ -1,238 +0,0 @@
|
|
|
1
|
-
import { DateInterval, LoggerType, parseResponse } from "@hyper-fetch/core";
|
|
2
|
-
|
|
3
|
-
import { EmitterInstance } from "emitter";
|
|
4
|
-
import { ListenerInstance } from "listener";
|
|
5
|
-
import { SocketInstance } from "socket";
|
|
6
|
-
import { getAdapter, WSAdapterOptionsType, ListenerCallbackType, WSMessageType } from "adapter";
|
|
7
|
-
|
|
8
|
-
export class SocketAdapter<SocketType extends SocketInstance> {
|
|
9
|
-
adapter: WebSocket | EventSource | undefined;
|
|
10
|
-
listeners: Map<string, Set<ListenerCallbackType>> = new Map();
|
|
11
|
-
open = false;
|
|
12
|
-
connecting = false;
|
|
13
|
-
forceClosed = false;
|
|
14
|
-
reconnectionAttempts = 0;
|
|
15
|
-
pingTimer: ReturnType<typeof setTimeout> | undefined;
|
|
16
|
-
pongTimer: ReturnType<typeof setTimeout> | undefined;
|
|
17
|
-
|
|
18
|
-
init: () => WebSocket | EventSource;
|
|
19
|
-
logger: LoggerType;
|
|
20
|
-
|
|
21
|
-
constructor(readonly socket: SocketType) {
|
|
22
|
-
this.init = () => getAdapter(socket);
|
|
23
|
-
this.logger = this.socket.loggerManager.init("Socket Adapter");
|
|
24
|
-
|
|
25
|
-
this.socket.appManager.events.onOnline(() => {
|
|
26
|
-
if (this.socket.autoConnect && !this.open) {
|
|
27
|
-
this.logger.info("Auto re-connecting");
|
|
28
|
-
this.connect();
|
|
29
|
-
}
|
|
30
|
-
});
|
|
31
|
-
|
|
32
|
-
if (this.socket.autoConnect) {
|
|
33
|
-
this.logger.info("Auto connecting");
|
|
34
|
-
this.connect();
|
|
35
|
-
}
|
|
36
|
-
}
|
|
37
|
-
|
|
38
|
-
connect = () => {
|
|
39
|
-
if (!this.socket.appManager.isOnline || this.connecting)
|
|
40
|
-
return this.logger.warning("Cannot initialize adapter.", {
|
|
41
|
-
connecting: this.connecting,
|
|
42
|
-
online: this.socket.appManager.isOnline,
|
|
43
|
-
});
|
|
44
|
-
const { reconnectTimeout = DateInterval.second * 2 } = this.socket.options.adapterOptions || {};
|
|
45
|
-
|
|
46
|
-
this.socket.events.emitConnecting();
|
|
47
|
-
|
|
48
|
-
// Clean environment
|
|
49
|
-
this.forceClosed = false;
|
|
50
|
-
this.adapter?.close();
|
|
51
|
-
|
|
52
|
-
// Start connection
|
|
53
|
-
this.connecting = true;
|
|
54
|
-
|
|
55
|
-
// Initialize new adapter instance
|
|
56
|
-
this.adapter = this.init();
|
|
57
|
-
|
|
58
|
-
if (!this.adapter) return this.logger.warning("Cannot initialize adapter.");
|
|
59
|
-
|
|
60
|
-
// Reconnection timeout
|
|
61
|
-
const timeout = setTimeout(() => {
|
|
62
|
-
this.reconnect();
|
|
63
|
-
}, reconnectTimeout);
|
|
64
|
-
|
|
65
|
-
/**
|
|
66
|
-
* Mount listeners
|
|
67
|
-
*/
|
|
68
|
-
|
|
69
|
-
this.adapter.onopen = (event) => {
|
|
70
|
-
this.logger.info("Connection open", { event });
|
|
71
|
-
clearTimeout(timeout);
|
|
72
|
-
this.socket.__onOpenCallbacks.forEach((callback) => {
|
|
73
|
-
callback(event, this.socket);
|
|
74
|
-
});
|
|
75
|
-
this.open = true;
|
|
76
|
-
this.connecting = false;
|
|
77
|
-
this.reconnectionAttempts = 0;
|
|
78
|
-
this.socket.events.emitOpen();
|
|
79
|
-
this.heartbeat();
|
|
80
|
-
};
|
|
81
|
-
|
|
82
|
-
if (this.adapter && "onclose" in this.adapter) {
|
|
83
|
-
this.adapter.onclose = (event) => {
|
|
84
|
-
this.logger.info("Connection closed", { event });
|
|
85
|
-
this.socket.__onCloseCallbacks.forEach((callback) => {
|
|
86
|
-
callback(event, this.socket);
|
|
87
|
-
});
|
|
88
|
-
this.open = false;
|
|
89
|
-
this.connecting = false;
|
|
90
|
-
this.socket.events.emitClose();
|
|
91
|
-
this.clearTimers();
|
|
92
|
-
};
|
|
93
|
-
}
|
|
94
|
-
|
|
95
|
-
this.adapter.onerror = (event) => {
|
|
96
|
-
this.logger.info("Error message", { event });
|
|
97
|
-
this.socket.__onErrorCallbacks.forEach((callback) => {
|
|
98
|
-
callback(event, this.socket);
|
|
99
|
-
});
|
|
100
|
-
this.socket.events.emitError(event);
|
|
101
|
-
};
|
|
102
|
-
|
|
103
|
-
this.adapter.onmessage = (event) => {
|
|
104
|
-
this.logger.info("New event message", { event });
|
|
105
|
-
|
|
106
|
-
const response = this.socket.__modifyResponse(event);
|
|
107
|
-
const data = parseResponse(response.data);
|
|
108
|
-
const listeners = this.listeners.get(data.name) || [];
|
|
109
|
-
listeners.forEach((callback) => {
|
|
110
|
-
callback(data, event);
|
|
111
|
-
});
|
|
112
|
-
this.socket.events.emitListenerEvent(data.name, data, event);
|
|
113
|
-
this.heartbeat();
|
|
114
|
-
};
|
|
115
|
-
};
|
|
116
|
-
|
|
117
|
-
disconnect = () => {
|
|
118
|
-
this.logger.debug("Disconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
119
|
-
this.open = false;
|
|
120
|
-
this.connecting = false;
|
|
121
|
-
this.forceClosed = true;
|
|
122
|
-
this.adapter.close();
|
|
123
|
-
this.clearTimers();
|
|
124
|
-
const isSSE = !(this.adapter && "onclose" in this.adapter);
|
|
125
|
-
if (isSSE) {
|
|
126
|
-
this.socket.__onCloseCallbacks.forEach((callback) => {
|
|
127
|
-
callback({}, this.socket);
|
|
128
|
-
});
|
|
129
|
-
this.socket.events.emitClose();
|
|
130
|
-
}
|
|
131
|
-
};
|
|
132
|
-
|
|
133
|
-
reconnect = () => {
|
|
134
|
-
this.disconnect();
|
|
135
|
-
if (this.reconnectionAttempts < this.socket.reconnect) {
|
|
136
|
-
this.reconnectionAttempts += 1;
|
|
137
|
-
this.logger.debug("Reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
138
|
-
this.connect();
|
|
139
|
-
this.socket.__onReconnectCallbacks.forEach((callback) => {
|
|
140
|
-
callback(this.socket);
|
|
141
|
-
});
|
|
142
|
-
this.socket.events.emitReconnecting(this.reconnectionAttempts);
|
|
143
|
-
return true;
|
|
144
|
-
}
|
|
145
|
-
this.logger.debug("Stopped reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
146
|
-
this.socket.__onReconnectStopCallbacks.forEach((callback) => {
|
|
147
|
-
callback(this.socket);
|
|
148
|
-
});
|
|
149
|
-
this.socket.events.emitReconnectingStop(this.reconnectionAttempts);
|
|
150
|
-
return false;
|
|
151
|
-
};
|
|
152
|
-
|
|
153
|
-
clearTimers = () => {
|
|
154
|
-
clearTimeout(this.pingTimer);
|
|
155
|
-
clearTimeout(this.pongTimer);
|
|
156
|
-
};
|
|
157
|
-
|
|
158
|
-
sendEventMessage = (payload: WSMessageType) => {
|
|
159
|
-
if (this.adapter && "send" in this.adapter) {
|
|
160
|
-
this.adapter.send(JSON.stringify({ id: payload.id, name: payload.name, data: payload.data }));
|
|
161
|
-
}
|
|
162
|
-
};
|
|
163
|
-
|
|
164
|
-
heartbeat = () => {
|
|
165
|
-
const options = (this.socket.options.adapterOptions || {}) as WSAdapterOptionsType;
|
|
166
|
-
const {
|
|
167
|
-
heartbeat = false,
|
|
168
|
-
pingTimeout = DateInterval.second * 5,
|
|
169
|
-
pongTimeout = DateInterval.second * 5,
|
|
170
|
-
heartbeatMessage = "heartbeat",
|
|
171
|
-
} = options;
|
|
172
|
-
if (this.connecting || !heartbeat) return;
|
|
173
|
-
if (this.adapter && "send" in this.adapter) {
|
|
174
|
-
this.clearTimers();
|
|
175
|
-
this.pingTimer = setTimeout(() => {
|
|
176
|
-
if (this.adapter && "send" in this.adapter) {
|
|
177
|
-
this.logger.debug("[Heartbeat]: Start");
|
|
178
|
-
const id = "heartbeat";
|
|
179
|
-
this.sendEventMessage({ id, data: heartbeatMessage, name: "heartbeat" });
|
|
180
|
-
this.pongTimer = setTimeout(() => {
|
|
181
|
-
this.logger.debug("[Heartbeat]: No response, closing connection");
|
|
182
|
-
this.adapter.close();
|
|
183
|
-
}, pongTimeout);
|
|
184
|
-
}
|
|
185
|
-
}, pingTimeout);
|
|
186
|
-
}
|
|
187
|
-
};
|
|
188
|
-
|
|
189
|
-
removeListener = (event: string, callback: (data: any, event: MessageEvent<any>) => void) => {
|
|
190
|
-
const listenerGroup = this.listeners.get(event);
|
|
191
|
-
if (listenerGroup && listenerGroup.has(callback)) {
|
|
192
|
-
this.logger.debug("Removed event listener", { event });
|
|
193
|
-
this.socket.events.emitListenerRemoveEvent(event);
|
|
194
|
-
listenerGroup.delete(callback);
|
|
195
|
-
return true;
|
|
196
|
-
}
|
|
197
|
-
return false;
|
|
198
|
-
};
|
|
199
|
-
|
|
200
|
-
listen = (listener: Pick<ListenerInstance, "name">, callback: (data: any, event: MessageEvent<any>) => void) => {
|
|
201
|
-
const listenerGroup =
|
|
202
|
-
this.listeners.get(listener.name) || this.listeners.set(listener.name, new Set()).get(listener.name);
|
|
203
|
-
|
|
204
|
-
listenerGroup.add(callback);
|
|
205
|
-
return () => this.removeListener(listener.name, callback);
|
|
206
|
-
};
|
|
207
|
-
|
|
208
|
-
emit = async (
|
|
209
|
-
eventMessageId: string,
|
|
210
|
-
emitter: EmitterInstance,
|
|
211
|
-
ack?: (error: Error | null, response: MessageEvent<any>) => void,
|
|
212
|
-
) => {
|
|
213
|
-
if (!this.connecting || !this.open) {
|
|
214
|
-
this.logger.error("Cannot emit event when connection is not open");
|
|
215
|
-
}
|
|
216
|
-
if (this.adapter && "send" in this.adapter) {
|
|
217
|
-
if (ack) {
|
|
218
|
-
let timeout;
|
|
219
|
-
const unmount = this.listen({ name: emitter.name }, (response) => {
|
|
220
|
-
if (response.id === eventMessageId) {
|
|
221
|
-
ack(null, response);
|
|
222
|
-
clearTimeout(timeout);
|
|
223
|
-
}
|
|
224
|
-
});
|
|
225
|
-
timeout = setTimeout(() => {
|
|
226
|
-
unmount();
|
|
227
|
-
ack(new Error("Server did not acknowledge the event"), null);
|
|
228
|
-
}, emitter.timeout);
|
|
229
|
-
}
|
|
230
|
-
|
|
231
|
-
const emitterInstance = await this.socket.__modifySend(emitter);
|
|
232
|
-
this.sendEventMessage({ id: eventMessageId, data: emitterInstance.data, name: emitterInstance.name });
|
|
233
|
-
this.socket.events.emitEmitterEvent(emitterInstance);
|
|
234
|
-
} else {
|
|
235
|
-
throw new Error("Cannot emit events in SSE mode");
|
|
236
|
-
}
|
|
237
|
-
};
|
|
238
|
-
}
|