@hyper-fetch/sockets 6.0.0 → 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.
Files changed (41) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +6 -6
  3. package/dist/index.d.ts +523 -296
  4. package/dist/index.js +1246 -0
  5. package/dist/index.js.map +7 -0
  6. package/package.json +8 -9
  7. package/src/adapter/adapter.bindings.ts +128 -101
  8. package/src/adapter/adapter.ts +231 -0
  9. package/src/adapter/adapter.types.ts +10 -101
  10. package/src/adapter/index.ts +4 -4
  11. package/src/adapter-sse/index.ts +3 -0
  12. package/src/adapter-sse/sse-adapter.ts +192 -0
  13. package/src/adapter-sse/sse-adapter.types.ts +6 -0
  14. package/src/adapter-sse/sse-adapter.utils.ts +77 -0
  15. package/src/adapter-websockets/index.ts +3 -0
  16. package/src/adapter-websockets/websocket-adapter.ts +259 -0
  17. package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
  18. package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
  19. package/src/emitter/emitter.ts +60 -102
  20. package/src/emitter/emitter.types.ts +82 -49
  21. package/src/index.ts +3 -0
  22. package/src/listener/listener.ts +34 -49
  23. package/src/listener/listener.types.ts +69 -17
  24. package/src/socket/socket.events.ts +147 -112
  25. package/src/socket/socket.ts +78 -100
  26. package/src/socket/socket.types.ts +13 -18
  27. package/src/socket/socket.utils.ts +12 -14
  28. package/src/types/connect.types.ts +2 -2
  29. package/src/types/extract.types.ts +43 -10
  30. package/src/utils/index.ts +3 -0
  31. package/src/utils/message-event.utils.ts +6 -0
  32. package/src/utils/socket.errors.ts +48 -0
  33. package/src/utils/socket.utils.ts +4 -0
  34. package/tsconfig.json +7 -3
  35. package/dist/index.cjs.js +0 -853
  36. package/dist/index.cjs.js.map +0 -7
  37. package/dist/index.esm.js +0 -833
  38. package/dist/index.esm.js.map +0 -7
  39. package/src/adapter/adapter.sse.ts +0 -127
  40. package/src/adapter/adapter.utils.ts +0 -20
  41. package/src/adapter/adapter.websocket.ts +0 -187
@@ -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
- ReconnectStopCallbackType,
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 { ExtractSocketExtraType, SocketAdapterInstance, WebsocketAdapterType, websocketAdapter } from "adapter";
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<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
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
- reconnect: number;
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
- __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
- __onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
49
- __onErrorCallbacks: ErrorCallbackType<Socket<AdapterType>, any>[] = [];
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: ReturnType<AdapterType>;
53
- loggerManager = new LoggerManager(this);
43
+ adapter: Adapter;
44
+ loggerManager = new LoggerManager();
54
45
  appManager = new AppManager();
55
- queryParamsConfig?: QueryStringifyOptionsType;
56
46
 
57
47
  // 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
- };
48
+ logger = this.loggerManager.initialize(this, "Socket");
66
49
 
67
- constructor(public options: SocketOptionsType<AdapterType>) {
68
- const {
69
- url,
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.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
- }
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
- this.adapter = (adapter ? adapter(this) : websocketAdapter(this)) as unknown as ReturnType<AdapterType>;
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 enables the logger usage and display the logs in console
69
+ * This method connects the socket to the server
100
70
  */
101
- setDebug = (debug: boolean) => {
102
- this.debug = debug;
103
- return this;
71
+ connect = async () => {
72
+ await this.adapter.connect();
104
73
  };
105
74
 
106
75
  /**
107
- * Set the logger severity of the messages displayed to the console
76
+ * This method disconnects the socket from the server
108
77
  */
109
- setLoggerSeverity = (severity: SeverityType) => {
110
- this.loggerManager.setSeverity(severity);
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
- * Set the new logger instance to the socket
95
+ * This method enables the logger usage and display the logs in console
116
96
  */
117
- setLogger = (callback: (socket: Socket<AdapterType>) => LoggerManager) => {
118
- this.loggerManager = callback(this);
97
+ setDebug = (enabled: boolean) => {
98
+ this.debug = enabled;
119
99
  return this;
120
100
  };
121
101
 
122
102
  /**
123
- * Set the new auth data to the socket
103
+ * Set the logger severity of the messages displayed to the console
124
104
  */
125
- setAuth = (auth: QueryParamsType | string) => {
126
- this.auth = auth;
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 query data to the socket
111
+ * Set the new logger instance to the socket
133
112
  */
134
- setQuery = (queryParams: QueryParamsType | string) => {
135
- this.queryParams = queryParams;
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
- onOpen(callback: OpenCallbackType<Socket<AdapterType>>) {
150
- this.__onOpenCallbacks.push(callback);
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
- onClose(callback: CloseCallbackType<Socket<AdapterType>>) {
159
- this.__onCloseCallbacks.push(callback);
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<Socket<AdapterType>>) {
169
- this.__onReconnectCallbacks.push(callback);
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
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<AdapterType>>) {
179
- this.__onReconnectStopCallbacks.push(callback);
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 = ExtractSocketExtraType<AdapterType>>(callback: MessageCallbackType<Socket<AdapterType>, Event>) {
189
- this.__onMessageCallbacks.push(callback);
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<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>) {
199
- this.__onSendCallbacks.push(callback);
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 = ExtractSocketExtraType<AdapterType>>(callback: ErrorCallbackType<Socket<AdapterType>, Event>) {
209
- this.__onErrorCallbacks.push(callback);
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
- __modifySend = (emitter: EmitterInstance) => {
220
- return interceptEmitter(this.__onSendCallbacks, emitter);
197
+ unstable__modifySend = (emitter: EmitterInstance) => {
198
+ return interceptEmitter(this.unstable_onSendCallbacks, emitter);
221
199
  };
222
200
 
223
- __modifyResponse = (data: { data: any; extra: ExtractSocketExtraType<AdapterType> }) => {
224
- return interceptListener(this.__onMessageCallbacks, data, 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, AdapterType>) => {
240
- return new Listener<Response, Endpoint, AdapterType>(this, options);
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, Response = never>() => {
250
- return <Endpoint extends string>(options: EmitterOptionsType<Endpoint, AdapterType>) => {
251
- return new Emitter<Payload, Response, Endpoint, AdapterType>(this, options);
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 { ExtractSocketOptionsType, SocketAdapterInstance } from "adapter";
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<AdapterType extends SocketAdapterInstance> = {
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
- queryParams?: QueryParamsType | string;
16
- autoConnect?: boolean;
17
- queryParamsConfig?: QueryStringifyOptionsType;
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<SocketType extends SocketInstance> = (socket: SocketType) => void;
23
- export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
24
- export type OpenCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
25
- export type CloseCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
26
- export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
27
- export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
28
- export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
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, SocketInstance } from "./socket.types";
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 getReconnectingStopKey = () => "socket_reconnecting_stop";
9
+ export const getReconnectingFailedKey = () => "socket_reconnecting_stop";
10
10
  export const getListenerEventKey = () => `listener_event`;
11
11
  export const getListenerRemoveKey = () => `listener_remove`;
12
- export const getEmitterEventKey = () => `emitter_event`;
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`;
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 = <Socket extends SocketInstance>(
18
- interceptors: MessageCallbackType<Socket, any>[],
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, socket);
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 { ListenerCallbackType, SocketAdapterInstance } from "adapter";
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, 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;
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 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;
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,3 @@
1
+ export * from "./message-event.utils";
2
+ export * from "./socket.utils";
3
+ export * from "./socket.errors";
@@ -0,0 +1,6 @@
1
+ import { parseResponse } from "@hyper-fetch/core";
2
+
3
+ export const parseMessageEvent = <T extends { topic: string; data: any; event: any }>(event: MessageEvent<any>) => {
4
+ const parsedEvent = parseResponse(event.data) as T;
5
+ return { ...parsedEvent, event };
6
+ };
@@ -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
+ };
@@ -0,0 +1,4 @@
1
+ export const getSocketUrl = (url: string, queryParams: string) => {
2
+ const fullUrl = `${url}${queryParams}`;
3
+ return fullUrl;
4
+ };
package/tsconfig.json CHANGED
@@ -1,8 +1,12 @@
1
1
  {
2
2
  "extends": "../../tsconfig.json",
3
3
  "compilerOptions": {
4
- "rootDir": ".",
5
- "baseUrl": "./src"
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
  }