@hyper-fetch/sockets 2.0.0 → 3.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.
@@ -5,22 +5,23 @@ export type RemoveListenerCallbackType = () => void;
5
5
 
6
6
  export type ListenerCallbackType<D = any> = (data: D, event: MessageEvent<D>) => void;
7
7
 
8
- export type WebsocketClientType = {
8
+ export type AdapterType = {
9
9
  connecting: boolean;
10
10
  listeners: Map<string, Set<ListenerCallbackType>>;
11
11
  emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: any) => void) => void;
12
12
  listen: (listener: ListenerInstance, callback: ListenerCallbackType) => RemoveListenerCallbackType;
13
13
  removeListener: (name: string, callback: (...args: any) => void) => void;
14
14
  connect: () => void;
15
+ reconnect: () => void;
15
16
  disconnect: () => void;
16
17
  };
17
18
 
18
- export type ServerSentEventsClientOptionsType = {
19
+ export type SSEAdapterOptionsType = {
19
20
  eventSourceInit?: EventSourceInit;
20
21
  reconnectTimeout?: number;
21
22
  };
22
23
 
23
- export type WebsocketClientOptionsType = {
24
+ export type WSAdapterOptionsType = {
24
25
  protocols?: string[];
25
26
  pingTimeout?: number;
26
27
  pongTimeout?: number;
@@ -1,6 +1,6 @@
1
1
  import { SocketInstance } from "socket";
2
2
 
3
- export const getClient = (socket: SocketInstance) => {
3
+ export const getAdapter = (socket: SocketInstance) => {
4
4
  const queryParams = socket.queryParamsStringify(socket.queryParams).substring(1);
5
5
  const authParams = socket.queryParamsStringify(socket.auth).substring(1);
6
6
  const connector = queryParams && authParams ? "&" : "";
@@ -8,8 +8,8 @@ export const getClient = (socket: SocketInstance) => {
8
8
 
9
9
  if ("isSSE" in socket.options) {
10
10
  if (!window?.EventSource) return null;
11
- return new EventSource(fullUrl, socket.options.clientOptions?.eventSourceInit);
11
+ return new EventSource(fullUrl, socket.options.adapterOptions?.eventSourceInit);
12
12
  }
13
13
  if (!window?.WebSocket) return null;
14
- return new WebSocket(fullUrl, socket.options.clientOptions?.protocols);
14
+ return new WebSocket(fullUrl, socket.options.adapterOptions?.protocols);
15
15
  };
@@ -0,0 +1,3 @@
1
+ export * from "./adapter";
2
+ export * from "./adapter.types";
3
+ export * from "./adapter.utils";
@@ -2,20 +2,20 @@ import { DateInterval, getUniqueRequestId } from "@hyper-fetch/core";
2
2
 
3
3
  import { Socket } from "socket";
4
4
  import { EmitterOptionsType, EmitterCloneOptionsType } from "emitter";
5
- import { WebsocketClientType } from "client";
5
+ import { AdapterType } from "adapter";
6
6
  import { ExtractEmitterOptionsType } from "types/extract.types";
7
7
 
8
- export class Emitter<RequestDataType, ResponseDataType, ClientType extends WebsocketClientType, MappedData = void> {
8
+ export class Emitter<Payload, Response, Adapter extends AdapterType, MappedData = void> {
9
9
  readonly name: string;
10
10
  timeout: number;
11
- data: RequestDataType | null = null;
12
- options: ExtractEmitterOptionsType<ClientType>;
11
+ data: Payload | null = null;
12
+ options: ExtractEmitterOptionsType<Adapter>;
13
13
 
14
14
  constructor(
15
- readonly socket: Socket<ClientType>,
16
- readonly emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<ClientType>>,
17
- dump?: Partial<Emitter<RequestDataType, ResponseDataType, ClientType, MappedData>>,
18
- readonly dataMapper?: (data: RequestDataType) => MappedData,
15
+ readonly socket: Socket<Adapter>,
16
+ readonly emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<Adapter>>,
17
+ dump?: Partial<Emitter<Payload, Response, Adapter, MappedData>>,
18
+ readonly dataMapper?: (data: Payload) => MappedData,
19
19
  ) {
20
20
  const { name, timeout = DateInterval.second * 3, options } = emitterOptions;
21
21
  this.name = dump?.name ?? name;
@@ -24,7 +24,7 @@ export class Emitter<RequestDataType, ResponseDataType, ClientType extends Webso
24
24
  this.options = dump?.options ?? options;
25
25
  }
26
26
 
27
- setOptions(options: ExtractEmitterOptionsType<ClientType>) {
27
+ setOptions(options: ExtractEmitterOptionsType<Adapter>) {
28
28
  return this.clone({ options });
29
29
  }
30
30
 
@@ -32,46 +32,41 @@ export class Emitter<RequestDataType, ResponseDataType, ClientType extends Webso
32
32
  return this.clone({ timeout });
33
33
  }
34
34
 
35
- setData(data: RequestDataType) {
35
+ setData(data: Payload) {
36
36
  if (this.dataMapper) {
37
37
  return this.clone<MappedData>({ data: this.dataMapper(data) });
38
38
  }
39
39
  return this.clone({ data });
40
40
  }
41
41
 
42
- setDataMapper = <MapperData>(mapper: (data: RequestDataType) => MapperData) => {
43
- return this.clone<RequestDataType, MapperData>(undefined, mapper);
42
+ setDataMapper = <MapperData>(mapper: (data: Payload) => MapperData) => {
43
+ return this.clone<Payload, MapperData>(undefined, mapper);
44
44
  };
45
45
 
46
- clone<NewRequestDataType = RequestDataType, MapperData = MappedData>(
47
- config?: Partial<EmitterCloneOptionsType<NewRequestDataType, ExtractEmitterOptionsType<ClientType>>>,
48
- mapper?: (data: NewRequestDataType) => MapperData,
49
- ): Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData> {
50
- const dump: Partial<Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData>> = {
46
+ clone<NewPayload = Payload, MapperData = MappedData>(
47
+ config?: Partial<EmitterCloneOptionsType<NewPayload, ExtractEmitterOptionsType<Adapter>>>,
48
+ mapper?: (data: NewPayload) => MapperData,
49
+ ): Emitter<NewPayload, Response, Adapter, MapperData> {
50
+ const dump: Partial<Emitter<NewPayload, Response, Adapter, MapperData>> = {
51
51
  timeout: this.timeout,
52
52
  options: this.options,
53
- data: this.data as unknown as NewRequestDataType,
53
+ data: this.data as unknown as NewPayload,
54
54
  ...config,
55
55
  name: this.name,
56
56
  };
57
57
  const mapperFn = (mapper || this.dataMapper) as typeof mapper;
58
58
 
59
- return new Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData>(
60
- this.socket,
61
- this.emitterOptions,
62
- dump,
63
- mapperFn,
64
- );
59
+ return new Emitter<NewPayload, Response, Adapter, MapperData>(this.socket, this.emitterOptions, dump, mapperFn);
65
60
  }
66
61
 
67
62
  emit(
68
- options?: Partial<EmitterCloneOptionsType<RequestDataType, ExtractEmitterOptionsType<ClientType>>>,
69
- ack?: (error: Error | null, response: ResponseDataType) => void,
63
+ options?: Partial<EmitterCloneOptionsType<Payload, ExtractEmitterOptionsType<Adapter>>>,
64
+ ack?: (error: Error | null, response: Response) => void,
70
65
  ) {
71
66
  const instance = this.clone(options);
72
67
  const eventMessageId = getUniqueRequestId(this.name);
73
68
 
74
- this.socket.client.emit(eventMessageId, instance, ack);
69
+ this.socket.adapter.emit(eventMessageId, instance, ack);
75
70
  return eventMessageId;
76
71
  }
77
72
  }
package/src/index.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  export * from "./socket";
2
- export * from "./client";
2
+ export * from "./adapter";
3
3
  export * from "./emitter";
4
4
  export * from "./listener";
5
5
  export * from "./types";
@@ -1,42 +1,40 @@
1
1
  import { Socket } from "socket";
2
2
  import { ListenerOptionsType } from "listener";
3
- import { ListenerCallbackType, WebsocketClientType } from "client";
3
+ import { ListenerCallbackType, AdapterType } from "adapter";
4
4
  import { ExtractListenerOptionsType } from "types/extract.types";
5
5
 
6
- export class Listener<ResponseType, ClientType extends WebsocketClientType> {
6
+ export class Listener<Response, Adapter extends AdapterType> {
7
7
  readonly name: string;
8
- options?: ExtractListenerOptionsType<ClientType>;
8
+ options?: ExtractListenerOptionsType<Adapter>;
9
9
 
10
10
  constructor(
11
- readonly socket: Socket<ClientType>,
12
- readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<ClientType>>,
11
+ readonly socket: Socket<Adapter>,
12
+ readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<Adapter>>,
13
13
  ) {
14
14
  const { name, options } = listenerOptions;
15
15
  this.name = name;
16
16
  this.options = options;
17
17
  }
18
18
 
19
- setOptions(options: ExtractListenerOptionsType<ClientType>) {
19
+ setOptions(options: ExtractListenerOptionsType<Adapter>) {
20
20
  return this.clone({ options });
21
21
  }
22
22
 
23
- clone(
24
- config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<ClientType>>>,
25
- ): Listener<ResponseType, ClientType> {
26
- return new Listener<ResponseType, ClientType>(this.socket, {
23
+ clone(config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<Adapter>>>): Listener<Response, Adapter> {
24
+ return new Listener<Response, Adapter>(this.socket, {
27
25
  ...this.listenerOptions,
28
26
  ...config,
29
27
  name: this.name,
30
28
  });
31
29
  }
32
30
 
33
- listen(callback: (data: ListenerCallbackType<ResponseType>) => void) {
31
+ listen(callback: (data: ListenerCallbackType<Response>) => void) {
34
32
  const instance = this.clone();
35
33
 
36
- this.socket.client.listen(instance, callback);
34
+ this.socket.adapter.listen(instance, callback);
37
35
 
38
36
  const removeListener = () => {
39
- this.socket.client.removeListener(instance.name, callback);
37
+ this.socket.adapter.removeListener(instance.name, callback);
40
38
  };
41
39
 
42
40
  return [removeListener, callback] as const;
@@ -2,16 +2,16 @@ import EventEmitter from "events";
2
2
  import {
3
3
  stringifyQueryParams,
4
4
  StringifyCallbackType,
5
- QueryStringifyOptions,
5
+ QueryStringifyOptionsType,
6
6
  LoggerManager,
7
7
  SeverityType,
8
8
  AppManager,
9
9
  DateInterval,
10
- ClientQueryParamsType,
10
+ QueryParamsType,
11
11
  } from "@hyper-fetch/core";
12
12
 
13
13
  import {
14
- SocketConfig,
14
+ SocketAdapterOptionsType,
15
15
  ReconnectCallbackType,
16
16
  ReconnectStopCallbackType,
17
17
  OpenCallbackType,
@@ -23,36 +23,36 @@ import {
23
23
  interceptListener,
24
24
  interceptEmitter,
25
25
  } from "socket";
26
- import { WebsocketClientType, SocketClient } from "client";
26
+ import { AdapterType, SocketAdapter } from "adapter";
27
27
  import { Listener, ListenerOptionsType } from "listener";
28
28
  import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
29
29
 
30
- export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
30
+ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
31
31
  public emitter = new EventEmitter();
32
32
  public events = getSocketEvents(this.emitter);
33
33
 
34
34
  url: string;
35
35
  reconnect: number;
36
36
  reconnectTime: number;
37
- auth?: ClientQueryParamsType | string;
38
- queryParams?: ClientQueryParamsType | string;
37
+ auth?: QueryParamsType | string;
38
+ queryParams?: QueryParamsType | string;
39
39
  debug: boolean;
40
40
  autoConnect: boolean;
41
41
 
42
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>[] = [];
43
+ __onOpenCallbacks: OpenCallbackType<Socket<Adapter>, any>[] = [];
44
+ __onCloseCallbacks: CloseCallbackType<Socket<Adapter>, any>[] = [];
45
+ __onReconnectCallbacks: ReconnectCallbackType<Socket<Adapter>>[] = [];
46
+ __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<Adapter>>[] = [];
47
+ __onMessageCallbacks: MessageCallbackType<Socket<Adapter>, any>[] = [];
48
48
  __onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
49
- __onErrorCallbacks: ErrorCallbackType<Socket<ClientType>, any>[] = [];
49
+ __onErrorCallbacks: ErrorCallbackType<Socket<Adapter>, any>[] = [];
50
50
 
51
51
  // Config
52
- client: ClientType;
52
+ adapter: Adapter;
53
53
  loggerManager = new LoggerManager(this);
54
54
  appManager = new AppManager();
55
- queryParamsConfig?: QueryStringifyOptions;
55
+ queryParamsConfig?: QueryStringifyOptionsType;
56
56
 
57
57
  // Logger
58
58
  logger = this.loggerManager.init("Socket");
@@ -64,11 +64,11 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
64
64
  return stringifyQueryParams(queryParams, this.queryParamsConfig);
65
65
  };
66
66
 
67
- constructor(public options: SocketConfig<ClientType>) {
67
+ constructor(public options: SocketAdapterOptionsType<Adapter>) {
68
68
  const {
69
69
  url,
70
70
  auth,
71
- client,
71
+ adapter,
72
72
  queryParams,
73
73
  autoConnect,
74
74
  reconnect,
@@ -91,8 +91,8 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
91
91
  this.queryParamsStringify = queryParamsStringify;
92
92
  }
93
93
 
94
- // Client must be initialized at the end
95
- this.client = client || (new SocketClient(this) as unknown as ClientType);
94
+ // Adapter must be initialized at the end
95
+ this.adapter = adapter || (new SocketAdapter(this) as unknown as Adapter);
96
96
  }
97
97
 
98
98
  /**
@@ -114,11 +114,29 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
114
114
  /**
115
115
  * Set the new logger instance to the socket
116
116
  */
117
- setLogger = (callback: (socket: Socket<ClientType>) => LoggerManager) => {
117
+ setLogger = (callback: (socket: Socket<Adapter>) => LoggerManager) => {
118
118
  this.loggerManager = callback(this);
119
119
  return this;
120
120
  };
121
121
 
122
+ /**
123
+ * Set the new auth data to the socket
124
+ */
125
+ setAuth = (auth: QueryParamsType | string) => {
126
+ this.auth = auth;
127
+ this.adapter.reconnect();
128
+ return this;
129
+ };
130
+
131
+ /**
132
+ * Set the new query data to the socket
133
+ */
134
+ setQuery = (queryParams: QueryParamsType | string) => {
135
+ this.queryParams = queryParams;
136
+ this.adapter.reconnect();
137
+ return this;
138
+ };
139
+
122
140
  /**
123
141
  * Callbacks
124
142
  */
@@ -128,7 +146,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
128
146
  * @param callback
129
147
  * @returns
130
148
  */
131
- onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<ClientType>, Event>) {
149
+ onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<Adapter>, Event>) {
132
150
  this.__onOpenCallbacks.push(callback);
133
151
  return this;
134
152
  }
@@ -137,7 +155,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
137
155
  * @param callback
138
156
  * @returns
139
157
  */
140
- onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<ClientType>, Event>) {
158
+ onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<Adapter>, Event>) {
141
159
  this.__onCloseCallbacks.push(callback);
142
160
  return this;
143
161
  }
@@ -147,7 +165,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
147
165
  * @param callback
148
166
  * @returns
149
167
  */
150
- onReconnect(callback: ReconnectCallbackType<Socket<ClientType>>) {
168
+ onReconnect(callback: ReconnectCallbackType<Socket<Adapter>>) {
151
169
  this.__onReconnectCallbacks.push(callback);
152
170
  return this;
153
171
  }
@@ -157,7 +175,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
157
175
  * @param callback
158
176
  * @returns
159
177
  */
160
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<ClientType>>) {
178
+ onReconnectStop(callback: ReconnectStopCallbackType<Socket<Adapter>>) {
161
179
  this.__onReconnectStopCallbacks.push(callback);
162
180
  return this;
163
181
  }
@@ -167,7 +185,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
167
185
  * @param callback
168
186
  * @returns
169
187
  */
170
- onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<ClientType>, Event>) {
188
+ onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<Adapter>, Event>) {
171
189
  this.__onMessageCallbacks.push(callback);
172
190
  return this;
173
191
  }
@@ -187,7 +205,7 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
187
205
  * @param callback
188
206
  * @returns
189
207
  */
190
- onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<ClientType>, Event>) {
208
+ onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<Adapter>, Event>) {
191
209
  this.__onErrorCallbacks.push(callback);
192
210
  return this;
193
211
  }
@@ -217,8 +235,8 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
217
235
  * @param options
218
236
  * @returns
219
237
  */
220
- createListener = <ResponseType>(options: ListenerOptionsType<ClientType>) => {
221
- return new Listener<ResponseType, ClientType>(this, options as any);
238
+ createListener = <Response>(options: ListenerOptionsType<Adapter>) => {
239
+ return new Listener<Response, Adapter>(this, options as any);
222
240
  };
223
241
 
224
242
  /**
@@ -226,10 +244,10 @@ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
226
244
  * @param options
227
245
  * @returns
228
246
  */
229
- createEmitter = <RequestDataType, ResponseDataType = never>(options: EmitterOptionsType<ClientType>) => {
247
+ createEmitter = <Payload, Response = never>(options: EmitterOptionsType<Adapter>) => {
230
248
  if ("isSSE" in this.options) {
231
- throw new Error("Cannot create emitters for SSE client");
249
+ throw new Error("Cannot create emitters for SSE adapter");
232
250
  }
233
- return new Emitter<RequestDataType, ResponseDataType, ClientType>(this, options as any);
251
+ return new Emitter<Payload, Response, Adapter>(this, options as any);
234
252
  };
235
253
  }
@@ -1,27 +1,27 @@
1
- import { ClientQueryParamsType, QueryStringifyOptions, StringifyCallbackType } from "@hyper-fetch/core";
1
+ import { QueryParamsType, QueryStringifyOptionsType, StringifyCallbackType } from "@hyper-fetch/core";
2
2
 
3
3
  import { Socket } from "socket";
4
- import { ServerSentEventsClientOptionsType, WebsocketClientOptionsType } from "client";
4
+ import { SSEAdapterOptionsType, WSAdapterOptionsType } from "adapter";
5
5
  import { EmitterInstance } from "emitter";
6
6
 
7
7
  export type SocketInstance = Socket<any>;
8
8
 
9
- export type SocketConfigBaseType<SocketClientType> = {
9
+ export type SocketOptionsType<SocketAdapterType> = {
10
10
  url: string;
11
- client?: SocketClientType;
12
- auth?: ClientQueryParamsType;
13
- queryParams?: ClientQueryParamsType | string;
11
+ adapter?: SocketAdapterType;
12
+ auth?: QueryParamsType;
13
+ queryParams?: QueryParamsType | string;
14
14
  reconnect?: number;
15
15
  reconnectTime?: number;
16
16
  autoConnect?: boolean;
17
- queryParamsConfig?: QueryStringifyOptions;
17
+ queryParamsConfig?: QueryStringifyOptionsType;
18
18
  queryParamsStringify?: StringifyCallbackType;
19
19
  };
20
20
 
21
- export type SocketConfig<SocketClientType> =
22
- | (SocketConfigBaseType<SocketClientType> & { isSSE: true; clientOptions?: ServerSentEventsClientOptionsType })
23
- | (SocketConfigBaseType<SocketClientType> & {
24
- clientOptions?: WebsocketClientOptionsType;
21
+ export type SocketAdapterOptionsType<SocketAdapterType> =
22
+ | (SocketOptionsType<SocketAdapterType> & { isSSE: true; adapterOptions?: SSEAdapterOptionsType })
23
+ | (SocketOptionsType<SocketAdapterType> & {
24
+ adapterOptions?: WSAdapterOptionsType;
25
25
  });
26
26
 
27
27
  export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
@@ -14,10 +14,10 @@ export const getListenerRemoveByNameKey = (event: string) => `${event}_listener_
14
14
  export const getListenerEventByNameKey = (event: string) => `${event}_listener_event`;
15
15
  export const getEmitterEventByNameKey = (event: string) => `${event}_emitter_event`;
16
16
 
17
- export const interceptListener = <SocketType extends SocketInstance>(
18
- interceptors: MessageCallbackType<SocketType, MessageEvent>[],
17
+ export const interceptListener = <Socket extends SocketInstance>(
18
+ interceptors: MessageCallbackType<Socket, MessageEvent>[],
19
19
  response: MessageEvent,
20
- socket: SocketType,
20
+ socket: Socket,
21
21
  ) => {
22
22
  let newResponse = response;
23
23
  // eslint-disable-next-line no-restricted-syntax
@@ -1,16 +1,20 @@
1
- import { WebsocketClientType } from "client";
1
+ import { AdapterType } from "adapter";
2
2
  import { Emitter } from "emitter";
3
3
  import { Listener } from "listener";
4
4
 
5
- // Emitter
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"];
6
9
 
7
- export type ExtractEmitterOptionsType<T extends Record<keyof WebsocketClientType | string, any>> = T["emitterOptions"];
10
+ // Emitter
8
11
 
9
- export type ExtractListenerOptionsType<T extends Record<keyof WebsocketClientType | string, any>> =
10
- T["listenerOptions"];
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 ExtractEmitterAdapterType<E> = E extends Emitter<any, any, infer A, any> ? A : never;
15
+ export type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, infer M> ? M : never;
11
16
 
12
17
  // Listener
13
18
 
14
19
  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;
20
+ export type ExtractListenerAdapterType<E> = E extends Listener<any, infer A> ? A : never;
@@ -1,2 +0,0 @@
1
- import { SocketInstance } from "socket";
2
- export declare const getClient: (socket: SocketInstance) => WebSocket | EventSource;
@@ -1,3 +0,0 @@
1
- export * from "./client";
2
- export * from "./client.types";
3
- export * from "./client.utils";
@@ -1,3 +0,0 @@
1
- export * from "./client";
2
- export * from "./client.types";
3
- export * from "./client.utils";