@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/src/socket/socket.ts
CHANGED
|
@@ -1,19 +1,10 @@
|
|
|
1
1
|
import EventEmitter from "events";
|
|
2
|
-
import {
|
|
3
|
-
stringifyQueryParams,
|
|
4
|
-
StringifyCallbackType,
|
|
5
|
-
QueryStringifyOptionsType,
|
|
6
|
-
LoggerManager,
|
|
7
|
-
SeverityType,
|
|
8
|
-
AppManager,
|
|
9
|
-
DateInterval,
|
|
10
|
-
QueryParamsType,
|
|
11
|
-
} from "@hyper-fetch/core";
|
|
2
|
+
import { LoggerManager, LogLevel, AppManager, Time } from "@hyper-fetch/core";
|
|
12
3
|
|
|
13
4
|
import {
|
|
14
5
|
SocketOptionsType,
|
|
15
6
|
ReconnectCallbackType,
|
|
16
|
-
|
|
7
|
+
ReconnectFailedCallbackType,
|
|
17
8
|
OpenCallbackType,
|
|
18
9
|
CloseCallbackType,
|
|
19
10
|
MessageCallbackType,
|
|
@@ -25,115 +16,102 @@ import {
|
|
|
25
16
|
} from "socket";
|
|
26
17
|
import { Listener, ListenerOptionsType } from "listener";
|
|
27
18
|
import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
|
|
28
|
-
import {
|
|
19
|
+
import { SocketAdapterInstance } from "adapter";
|
|
20
|
+
import { ExtractAdapterExtraType, ExtractAdapterQueryParamsType } from "types";
|
|
21
|
+
import { WebsocketAdapter, WebsocketAdapterType } from "adapter-websockets/websocket-adapter";
|
|
29
22
|
|
|
30
|
-
export class Socket<
|
|
23
|
+
export class Socket<Adapter extends SocketAdapterInstance = WebsocketAdapterType> {
|
|
31
24
|
public emitter = new EventEmitter();
|
|
32
25
|
public events = getSocketEvents(this.emitter);
|
|
33
26
|
|
|
34
27
|
url: string;
|
|
35
|
-
|
|
28
|
+
reconnectAttempts: number;
|
|
36
29
|
reconnectTime: number;
|
|
37
|
-
auth?: QueryParamsType | string;
|
|
38
|
-
queryParams?: QueryParamsType | string;
|
|
39
30
|
debug: boolean;
|
|
40
31
|
autoConnect: boolean;
|
|
41
32
|
|
|
42
33
|
// Callbacks
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
34
|
+
unstable_onConnectedCallbacks: OpenCallbackType[] = [];
|
|
35
|
+
unstable_onDisconnectCallbacks: CloseCallbackType[] = [];
|
|
36
|
+
unstable_onReconnectCallbacks: ReconnectCallbackType[] = [];
|
|
37
|
+
unstable_onReconnectFailedCallbacks: ReconnectFailedCallbackType[] = [];
|
|
38
|
+
unstable_onMessageCallbacks: MessageCallbackType<any>[] = [];
|
|
39
|
+
unstable_onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
|
|
40
|
+
unstable_onErrorCallbacks: ErrorCallbackType<any>[] = [];
|
|
50
41
|
|
|
51
42
|
// Config
|
|
52
|
-
adapter:
|
|
53
|
-
loggerManager = new LoggerManager(
|
|
43
|
+
adapter: Adapter;
|
|
44
|
+
loggerManager = new LoggerManager();
|
|
54
45
|
appManager = new AppManager();
|
|
55
|
-
queryParamsConfig?: QueryStringifyOptionsType;
|
|
56
46
|
|
|
57
47
|
// Logger
|
|
58
|
-
logger = this.loggerManager.
|
|
59
|
-
|
|
60
|
-
/**
|
|
61
|
-
* Method to stringify query params from objects.
|
|
62
|
-
*/
|
|
63
|
-
queryParamsStringify: StringifyCallbackType = (queryParams) => {
|
|
64
|
-
return stringifyQueryParams(queryParams, this.queryParamsConfig);
|
|
65
|
-
};
|
|
48
|
+
logger = this.loggerManager.initialize(this, "Socket");
|
|
66
49
|
|
|
67
|
-
constructor(public options: SocketOptionsType<
|
|
68
|
-
const {
|
|
69
|
-
|
|
70
|
-
auth,
|
|
71
|
-
adapter,
|
|
72
|
-
queryParams,
|
|
73
|
-
autoConnect,
|
|
74
|
-
reconnect,
|
|
75
|
-
reconnectTime,
|
|
76
|
-
queryParamsConfig,
|
|
77
|
-
queryParamsStringify,
|
|
78
|
-
} = this.options;
|
|
50
|
+
constructor(public options: SocketOptionsType<Adapter>) {
|
|
51
|
+
const { url, adapter, reconnect, reconnectTime, queryParams } = this.options;
|
|
52
|
+
this.emitter?.setMaxListeners(1000);
|
|
79
53
|
this.url = url;
|
|
80
|
-
this.auth = auth;
|
|
81
|
-
this.queryParams = queryParams;
|
|
82
54
|
this.debug = false;
|
|
83
|
-
this.
|
|
84
|
-
this.
|
|
85
|
-
this.
|
|
86
|
-
|
|
87
|
-
if (queryParamsConfig) {
|
|
88
|
-
this.queryParamsConfig = queryParamsConfig;
|
|
89
|
-
}
|
|
90
|
-
if (queryParamsStringify) {
|
|
91
|
-
this.queryParamsStringify = queryParamsStringify;
|
|
92
|
-
}
|
|
55
|
+
this.reconnectAttempts = reconnect ?? Infinity;
|
|
56
|
+
this.reconnectTime = reconnectTime ?? Time.SEC * 5;
|
|
57
|
+
this.autoConnect = true;
|
|
93
58
|
|
|
94
59
|
// Adapter must be initialized at the end
|
|
95
|
-
|
|
60
|
+
const instanceOfAdapter = typeof adapter === "function" ? adapter() : adapter;
|
|
61
|
+
this.adapter = instanceOfAdapter || (WebsocketAdapter() as unknown as Adapter);
|
|
62
|
+
if (queryParams) {
|
|
63
|
+
this.adapter.setQueryParams(queryParams);
|
|
64
|
+
}
|
|
65
|
+
this.adapter.initialize(this);
|
|
96
66
|
}
|
|
97
67
|
|
|
98
68
|
/**
|
|
99
|
-
* This method
|
|
69
|
+
* This method connects the socket to the server
|
|
100
70
|
*/
|
|
101
|
-
|
|
102
|
-
this.
|
|
103
|
-
return this;
|
|
71
|
+
connect = async () => {
|
|
72
|
+
await this.adapter.connect();
|
|
104
73
|
};
|
|
105
74
|
|
|
106
75
|
/**
|
|
107
|
-
*
|
|
76
|
+
* This method disconnects the socket from the server
|
|
108
77
|
*/
|
|
109
|
-
|
|
110
|
-
this.
|
|
78
|
+
disconnect = async () => {
|
|
79
|
+
await this.adapter.disconnect();
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
/**
|
|
83
|
+
* This method reconnect the socket to the server
|
|
84
|
+
*/
|
|
85
|
+
reconnect = async () => {
|
|
86
|
+
await this.adapter.reconnect();
|
|
87
|
+
};
|
|
88
|
+
|
|
89
|
+
setQueryParams = (queryParams: ExtractAdapterQueryParamsType<Adapter>) => {
|
|
90
|
+
this.adapter.setQueryParams(queryParams);
|
|
111
91
|
return this;
|
|
112
92
|
};
|
|
113
93
|
|
|
114
94
|
/**
|
|
115
|
-
*
|
|
95
|
+
* This method enables the logger usage and display the logs in console
|
|
116
96
|
*/
|
|
117
|
-
|
|
118
|
-
this.
|
|
97
|
+
setDebug = (enabled: boolean) => {
|
|
98
|
+
this.debug = enabled;
|
|
119
99
|
return this;
|
|
120
100
|
};
|
|
121
101
|
|
|
122
102
|
/**
|
|
123
|
-
* Set the
|
|
103
|
+
* Set the logger severity of the messages displayed to the console
|
|
124
104
|
*/
|
|
125
|
-
|
|
126
|
-
this.
|
|
127
|
-
this.adapter.reconnect();
|
|
105
|
+
setLogLevel = (level: LogLevel) => {
|
|
106
|
+
this.loggerManager.setSeverity(level);
|
|
128
107
|
return this;
|
|
129
108
|
};
|
|
130
109
|
|
|
131
110
|
/**
|
|
132
|
-
* Set the new
|
|
111
|
+
* Set the new logger instance to the socket
|
|
133
112
|
*/
|
|
134
|
-
|
|
135
|
-
this.
|
|
136
|
-
this.adapter.reconnect();
|
|
113
|
+
setLogger = (callback: (socket: Socket<Adapter>) => LoggerManager) => {
|
|
114
|
+
this.loggerManager = callback(this);
|
|
137
115
|
return this;
|
|
138
116
|
};
|
|
139
117
|
|
|
@@ -146,8 +124,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
146
124
|
* @param callback
|
|
147
125
|
* @returns
|
|
148
126
|
*/
|
|
149
|
-
|
|
150
|
-
this.
|
|
127
|
+
onConnected(callback: OpenCallbackType) {
|
|
128
|
+
this.unstable_onConnectedCallbacks.push(callback);
|
|
151
129
|
return this;
|
|
152
130
|
}
|
|
153
131
|
/**
|
|
@@ -155,8 +133,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
155
133
|
* @param callback
|
|
156
134
|
* @returns
|
|
157
135
|
*/
|
|
158
|
-
|
|
159
|
-
this.
|
|
136
|
+
onDisconnected(callback: CloseCallbackType) {
|
|
137
|
+
this.unstable_onDisconnectCallbacks.push(callback);
|
|
160
138
|
return this;
|
|
161
139
|
}
|
|
162
140
|
|
|
@@ -165,8 +143,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
165
143
|
* @param callback
|
|
166
144
|
* @returns
|
|
167
145
|
*/
|
|
168
|
-
onReconnect(callback: ReconnectCallbackType
|
|
169
|
-
this.
|
|
146
|
+
onReconnect(callback: ReconnectCallbackType) {
|
|
147
|
+
this.unstable_onReconnectCallbacks.push(callback);
|
|
170
148
|
return this;
|
|
171
149
|
}
|
|
172
150
|
|
|
@@ -175,8 +153,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
175
153
|
* @param callback
|
|
176
154
|
* @returns
|
|
177
155
|
*/
|
|
178
|
-
|
|
179
|
-
this.
|
|
156
|
+
onReconnectFailed(callback: ReconnectFailedCallbackType) {
|
|
157
|
+
this.unstable_onReconnectFailedCallbacks.push(callback);
|
|
180
158
|
return this;
|
|
181
159
|
}
|
|
182
160
|
|
|
@@ -185,8 +163,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
185
163
|
* @param callback
|
|
186
164
|
* @returns
|
|
187
165
|
*/
|
|
188
|
-
onMessage<Event
|
|
189
|
-
this.
|
|
166
|
+
onMessage<Event>(callback: MessageCallbackType<Event>) {
|
|
167
|
+
this.unstable_onMessageCallbacks.push(callback);
|
|
190
168
|
return this;
|
|
191
169
|
}
|
|
192
170
|
|
|
@@ -195,8 +173,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
195
173
|
* @param callback
|
|
196
174
|
* @returns
|
|
197
175
|
*/
|
|
198
|
-
onSend
|
|
199
|
-
this.
|
|
176
|
+
onSend(callback: SendCallbackType<EmitterInstance>) {
|
|
177
|
+
this.unstable_onSendCallbacks.push(callback);
|
|
200
178
|
return this;
|
|
201
179
|
}
|
|
202
180
|
|
|
@@ -205,8 +183,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
205
183
|
* @param callback
|
|
206
184
|
* @returns
|
|
207
185
|
*/
|
|
208
|
-
onError<Event
|
|
209
|
-
this.
|
|
186
|
+
onError<Event>(callback: ErrorCallbackType<Event>) {
|
|
187
|
+
this.unstable_onErrorCallbacks.push(callback);
|
|
210
188
|
return this;
|
|
211
189
|
}
|
|
212
190
|
|
|
@@ -216,12 +194,12 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
216
194
|
* ********************
|
|
217
195
|
*/
|
|
218
196
|
|
|
219
|
-
|
|
220
|
-
return interceptEmitter(this.
|
|
197
|
+
unstable__modifySend = (emitter: EmitterInstance) => {
|
|
198
|
+
return interceptEmitter(this.unstable_onSendCallbacks, emitter);
|
|
221
199
|
};
|
|
222
200
|
|
|
223
|
-
|
|
224
|
-
return interceptListener(this.
|
|
201
|
+
unstable__modifyResponse = (data: { data: any; extra: ExtractAdapterExtraType<Adapter> }) => {
|
|
202
|
+
return interceptListener(this.unstable_onMessageCallbacks, data);
|
|
225
203
|
};
|
|
226
204
|
|
|
227
205
|
/**
|
|
@@ -236,8 +214,8 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
236
214
|
* @returns
|
|
237
215
|
*/
|
|
238
216
|
createListener = <Response>() => {
|
|
239
|
-
return <Endpoint extends string>(options: ListenerOptionsType<Endpoint,
|
|
240
|
-
return new Listener<Response, Endpoint,
|
|
217
|
+
return <Endpoint extends string>(options: ListenerOptionsType<Endpoint, Adapter>) => {
|
|
218
|
+
return new Listener<Response, Endpoint, Socket<Adapter>>(this, options);
|
|
241
219
|
};
|
|
242
220
|
};
|
|
243
221
|
|
|
@@ -246,9 +224,9 @@ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapter
|
|
|
246
224
|
* @param options
|
|
247
225
|
* @returns
|
|
248
226
|
*/
|
|
249
|
-
createEmitter = <Payload
|
|
250
|
-
return <Endpoint extends string>(options: EmitterOptionsType<Endpoint,
|
|
251
|
-
return new Emitter<Payload,
|
|
227
|
+
createEmitter = <Payload>() => {
|
|
228
|
+
return <Endpoint extends string>(options: EmitterOptionsType<Endpoint, Adapter>) => {
|
|
229
|
+
return new Emitter<Payload, Endpoint, Socket<Adapter>>(this, options);
|
|
252
230
|
};
|
|
253
231
|
};
|
|
254
232
|
}
|
|
@@ -1,28 +1,23 @@
|
|
|
1
|
-
import { QueryParamsType, QueryStringifyOptionsType, StringifyCallbackType } from "@hyper-fetch/core";
|
|
2
|
-
|
|
3
1
|
import { Socket } from "socket";
|
|
4
|
-
import {
|
|
2
|
+
import { SocketAdapterInstance } from "adapter";
|
|
5
3
|
import { EmitterInstance } from "emitter";
|
|
4
|
+
import { ExtractAdapterOptionsType, ExtractAdapterQueryParamsType } from "types";
|
|
6
5
|
|
|
7
6
|
export type SocketInstance = Socket<SocketAdapterInstance>;
|
|
8
7
|
|
|
9
|
-
export type SocketOptionsType<
|
|
8
|
+
export type SocketOptionsType<Adapter extends SocketAdapterInstance> = {
|
|
10
9
|
url: string;
|
|
11
|
-
adapter?: AdapterType;
|
|
12
|
-
auth?: QueryParamsType;
|
|
13
10
|
reconnect?: number;
|
|
14
11
|
reconnectTime?: number;
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
queryParamsStringify?: StringifyCallbackType;
|
|
19
|
-
adapterOptions?: ExtractSocketOptionsType<AdapterType>;
|
|
12
|
+
adapter?: (() => Adapter) | Adapter;
|
|
13
|
+
adapterOptions?: ExtractAdapterOptionsType<Adapter>;
|
|
14
|
+
queryParams?: ExtractAdapterQueryParamsType<Adapter>;
|
|
20
15
|
};
|
|
21
16
|
|
|
22
|
-
export type ReconnectCallbackType
|
|
23
|
-
export type
|
|
24
|
-
export type OpenCallbackType
|
|
25
|
-
export type CloseCallbackType
|
|
26
|
-
export type MessageCallbackType<
|
|
27
|
-
export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
|
|
28
|
-
export type ErrorCallbackType<
|
|
17
|
+
export type ReconnectCallbackType = () => void;
|
|
18
|
+
export type ReconnectFailedCallbackType = () => void;
|
|
19
|
+
export type OpenCallbackType = () => void;
|
|
20
|
+
export type CloseCallbackType = () => void;
|
|
21
|
+
export type MessageCallbackType<Event> = (data: { event: Event }) => Event;
|
|
22
|
+
export type SendCallbackType<EmitterType extends EmitterInstance> = (data: { emitter: EmitterType }) => EmitterInstance;
|
|
23
|
+
export type ErrorCallbackType<Event> = (data: { error: Event }) => void;
|
|
@@ -1,28 +1,26 @@
|
|
|
1
1
|
import { EmitterInstance } from "emitter";
|
|
2
|
-
import { MessageCallbackType, SendCallbackType
|
|
2
|
+
import { MessageCallbackType, SendCallbackType } from "./socket.types";
|
|
3
3
|
|
|
4
4
|
export const getErrorKey = () => "socket_error";
|
|
5
5
|
export const getOpenKey = () => "socket_open";
|
|
6
6
|
export const getCloseKey = () => "socket_close";
|
|
7
7
|
export const getConnectingKey = () => "socket_connecting";
|
|
8
8
|
export const getReconnectingKey = () => "socket_reconnecting";
|
|
9
|
-
export const
|
|
9
|
+
export const getReconnectingFailedKey = () => "socket_reconnecting_stop";
|
|
10
10
|
export const getListenerEventKey = () => `listener_event`;
|
|
11
11
|
export const getListenerRemoveKey = () => `listener_remove`;
|
|
12
|
-
export const
|
|
13
|
-
export const
|
|
14
|
-
export const
|
|
15
|
-
export const
|
|
12
|
+
export const getEmitterStartEventKey = () => `emitter_start_event`;
|
|
13
|
+
export const getEmitterErrorKey = () => `emitter_error`;
|
|
14
|
+
export const getListenerRemoveByTopicKey = (event: string) => `${event}_listener_remove`;
|
|
15
|
+
export const getListenerEventByTopicKey = (event: string) => `${event}_listener_event`;
|
|
16
|
+
export const getEmitterStartEventByTopicKey = (event: string) => `${event}_emitter_start_event`;
|
|
17
|
+
export const getEmitterErrorByTopicKey = (event: string) => `${event}_emitter_error`;
|
|
16
18
|
|
|
17
|
-
export const interceptListener = <
|
|
18
|
-
|
|
19
|
-
data: { data: any; extra: any },
|
|
20
|
-
socket: Socket,
|
|
21
|
-
) => {
|
|
22
|
-
let newResponse = data;
|
|
19
|
+
export const interceptListener = (interceptors: MessageCallbackType<any>[], event: { data: any; extra: any }) => {
|
|
20
|
+
let newResponse = event;
|
|
23
21
|
// eslint-disable-next-line no-restricted-syntax
|
|
24
22
|
for (const interceptor of interceptors) {
|
|
25
|
-
newResponse = interceptor(data
|
|
23
|
+
newResponse = interceptor({ event: event.data });
|
|
26
24
|
if (!newResponse) throw new Error("Listener modifier must return data");
|
|
27
25
|
}
|
|
28
26
|
|
|
@@ -36,7 +34,7 @@ export const interceptEmitter = <EmitterType extends EmitterInstance>(
|
|
|
36
34
|
let newEmitter = emitter;
|
|
37
35
|
// eslint-disable-next-line no-restricted-syntax
|
|
38
36
|
for (const interceptor of interceptors) {
|
|
39
|
-
newEmitter = interceptor(emitter) as EmitterType;
|
|
37
|
+
newEmitter = interceptor({ emitter }) as EmitterType;
|
|
40
38
|
if (!newEmitter) throw new Error("Send modifier must return emitter");
|
|
41
39
|
}
|
|
42
40
|
return newEmitter;
|
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { SocketAdapterInstance } from "adapter";
|
|
2
|
+
import { ListenerCallbackType } from "listener";
|
|
2
3
|
|
|
3
4
|
export type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (
|
|
4
5
|
response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0],
|
|
5
|
-
unsubscribe: () => void,
|
|
6
6
|
) => void;
|
|
@@ -1,19 +1,52 @@
|
|
|
1
|
+
import { SocketAdapterInstance } from "adapter";
|
|
2
|
+
import { SocketAdapter } from "adapter/adapter";
|
|
1
3
|
import { Emitter } from "emitter";
|
|
2
4
|
import { Listener } from "listener";
|
|
5
|
+
import { Socket, SocketInstance } from "socket";
|
|
6
|
+
|
|
7
|
+
export type EventReturnType<GenericDataType, Adapter extends SocketAdapterInstance> = {
|
|
8
|
+
data: GenericDataType;
|
|
9
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
10
|
+
};
|
|
3
11
|
|
|
4
12
|
// Emitter
|
|
5
13
|
|
|
6
|
-
export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any
|
|
7
|
-
export type
|
|
8
|
-
export type
|
|
9
|
-
export type
|
|
10
|
-
export type
|
|
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;
|
|
14
|
+
export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any> ? P : never;
|
|
15
|
+
export type ExtractEmitterTopicType<E> = E extends Emitter<any, infer T, any, any, any> ? T : never;
|
|
16
|
+
export type ExtractEmitterSocketType<E> = E extends Emitter<any, any, infer A, any, any> ? A : never;
|
|
17
|
+
export type ExtractEmitterHasPayloadType<E> = E extends Emitter<any, any, any, infer D, any> ? D : never;
|
|
18
|
+
export type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, infer P> ? P : never;
|
|
13
19
|
|
|
14
20
|
// Listener
|
|
15
21
|
|
|
16
22
|
export type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
|
|
17
|
-
export type
|
|
18
|
-
export type
|
|
19
|
-
export type
|
|
23
|
+
export type ExtractListenerTopicType<E> = E extends Listener<any, infer T, any, any> ? T : never;
|
|
24
|
+
export type ExtractListenerSocketType<E> = E extends Listener<any, any, infer A, any> ? A : never;
|
|
25
|
+
export type ExtractListenerHasParamsType<E> = E extends Listener<any, any, any, infer P> ? P : never;
|
|
26
|
+
|
|
27
|
+
// Socket
|
|
28
|
+
|
|
29
|
+
export type ExtractSocketAdapterType<T extends SocketInstance> = T extends Socket<infer Adapter> ? Adapter : never;
|
|
30
|
+
export type ExtractSocketOptionsType<T extends SocketInstance> =
|
|
31
|
+
T extends Socket<infer Adapter> ? ExtractAdapterOptionsType<Adapter> : never;
|
|
32
|
+
export type ExtractSocketExtraType<T extends SocketInstance> =
|
|
33
|
+
T extends Socket<infer Adapter> ? ExtractAdapterExtraType<Adapter> : never;
|
|
34
|
+
export type ExtractListenerOptionsType<T extends SocketInstance> =
|
|
35
|
+
T extends Socket<infer Adapter> ? ExtractAdapterListenerOptionsType<Adapter> : never;
|
|
36
|
+
export type ExtractEmitterOptionsType<T extends SocketInstance> =
|
|
37
|
+
T extends Socket<infer Adapter> ? ExtractAdapterEmitterOptionsType<Adapter> : never;
|
|
38
|
+
|
|
39
|
+
// Adapter
|
|
40
|
+
|
|
41
|
+
export type ExtractAdapterExtraType<T extends SocketAdapterInstance> =
|
|
42
|
+
T extends SocketAdapter<infer P, any, any, any, any, any> ? P : never;
|
|
43
|
+
export type ExtractAdapterOptionsType<T extends SocketAdapterInstance> =
|
|
44
|
+
T extends SocketAdapter<any, infer P, any, any, any, any> ? P : never;
|
|
45
|
+
export type ExtractAdapterListenerOptionsType<T extends SocketAdapterInstance> =
|
|
46
|
+
T extends SocketAdapter<any, any, infer P, any, any, any> ? P : never;
|
|
47
|
+
export type ExtractAdapterEmitterOptionsType<T extends SocketAdapterInstance> =
|
|
48
|
+
T extends SocketAdapter<any, any, any, infer P, any, any> ? P : never;
|
|
49
|
+
export type ExtractAdapterQueryParamsType<T extends SocketAdapterInstance> =
|
|
50
|
+
T extends SocketAdapter<any, any, any, any, infer P, any> ? P : never;
|
|
51
|
+
export type ExtractAdapterQueryParamsMapperType<T extends SocketAdapterInstance> =
|
|
52
|
+
T extends SocketAdapter<any, any, any, any, any, infer P> ? P : never;
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
/* eslint-disable prefer-template */
|
|
2
|
+
|
|
3
|
+
export const getSocketError = (event: Event): string => {
|
|
4
|
+
if ("code" in event) {
|
|
5
|
+
switch (event.code) {
|
|
6
|
+
case 1000:
|
|
7
|
+
return "Normal closure, meaning that the purpose for which the connection was established has been fulfilled.";
|
|
8
|
+
case 1001:
|
|
9
|
+
return 'An endpoint is "going away", such as a server going down or a browser having navigated away from a page.';
|
|
10
|
+
case 1002:
|
|
11
|
+
return "An endpoint is terminating the connection due to a protocol error";
|
|
12
|
+
case 1003:
|
|
13
|
+
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).";
|
|
14
|
+
case 1004:
|
|
15
|
+
return "Reserved. The specific meaning might be defined in the future.";
|
|
16
|
+
case 1005:
|
|
17
|
+
return "No status code was actually present.";
|
|
18
|
+
case 1006:
|
|
19
|
+
return "The connection was closed abnormally, e.g., without sending or receiving a Close control frame";
|
|
20
|
+
case 1007:
|
|
21
|
+
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).";
|
|
22
|
+
case 1008:
|
|
23
|
+
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.';
|
|
24
|
+
case 1009:
|
|
25
|
+
return "An endpoint is terminating the connection because it has received a message that is too big for it to process.";
|
|
26
|
+
case 1010: {
|
|
27
|
+
const reason = "reason" in event ? event.reason : null;
|
|
28
|
+
// Note that this status code is not used by the server, because it can fail the WebSocket handshake instead.
|
|
29
|
+
return (
|
|
30
|
+
"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: " +
|
|
31
|
+
(reason || "Unknown reason")
|
|
32
|
+
);
|
|
33
|
+
}
|
|
34
|
+
case 1011:
|
|
35
|
+
return "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.";
|
|
36
|
+
case 1015:
|
|
37
|
+
return "The connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified).";
|
|
38
|
+
default:
|
|
39
|
+
return "Unknown reason";
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
if ("data" in event) {
|
|
44
|
+
return JSON.stringify(event.data);
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
return "There was an socket error";
|
|
48
|
+
};
|
package/tsconfig.json
CHANGED
|
@@ -1,8 +1,12 @@
|
|
|
1
1
|
{
|
|
2
2
|
"extends": "../../tsconfig.json",
|
|
3
3
|
"compilerOptions": {
|
|
4
|
-
"
|
|
5
|
-
"
|
|
4
|
+
"baseUrl": "./src",
|
|
5
|
+
"jsx": "react-jsx",
|
|
6
|
+
"outDir": "./dist",
|
|
7
|
+
"paths": {
|
|
8
|
+
"@hyper-fetch/sockets": ["../src"]
|
|
9
|
+
}
|
|
6
10
|
},
|
|
7
|
-
"exclude": ["dist", "jest.config.ts"]
|
|
11
|
+
"exclude": ["node_modules", "dist", "jest.config.ts", "__tests__"]
|
|
8
12
|
}
|