@hyper-fetch/sockets 4.0.1 → 5.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/dist/index.d.ts CHANGED
@@ -1,141 +1,258 @@
1
1
  import * as _hyper_fetch_core from '@hyper-fetch/core';
2
- import { LoggerType, QueryParamsType, LoggerManager, AppManager, QueryStringifyOptionsType, StringifyCallbackType, SeverityType } from '@hyper-fetch/core';
2
+ import { ParamsType, ExtractRouteParams, NegativeTypes, QueryParamsType, LoggerManager, AppManager, QueryStringifyOptionsType, StringifyCallbackType, SeverityType } from '@hyper-fetch/core';
3
3
  import EventEmitter from 'events';
4
4
 
5
- type ExtractEmitterOptionsType<E extends Record<keyof AdapterType | string, any>> = E["emitterOptions"];
6
- type ExtractListenerOptionsType<E extends Record<keyof AdapterType | string, any>> = E["listenerOptions"];
7
- type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any> ? P : never;
8
- type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any> ? R : never;
9
- type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, infer A, any> ? A : never;
10
- type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, infer M> ? M : never;
11
- type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
12
- type ExtractListenerAdapterType<E> = E extends Listener<any, infer A> ? A : never;
5
+ /**
6
+ * -------------------------------------------
7
+ * Websocket
8
+ * -------------------------------------------
9
+ */
10
+ declare const websocketAdapter: WebsocketAdapterType;
13
11
 
14
- declare class Emitter<Payload, Response, Adapter extends AdapterType, MappedData = void> {
15
- readonly socket: Socket<Adapter>;
16
- readonly emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<Adapter>>;
12
+ /**
13
+ * -------------------------------------------
14
+ * Websocket
15
+ * -------------------------------------------
16
+ */
17
+ declare const sseAdapter: SSEAdapterType;
18
+
19
+ type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
20
+
21
+ type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any, any, any> ? P : never;
22
+ type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any, any, any, any> ? R : never;
23
+ type ExtractEmitterEndpointType<E> = E extends Emitter<any, any, infer A, any, any, any, any> ? A : never;
24
+ type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, any, infer A, any, any, any> ? A : never;
25
+ type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, any, infer M, any, any> ? M : never;
26
+ type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, any, infer M, any> ? M : never;
27
+ type ExtractEmitterHasDataType<E> = E extends Emitter<any, any, any, any, any, any, infer D> ? D : never;
28
+ type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
29
+ type ExtractListenerEndpointType<E> = E extends Listener<any, infer A, any, any> ? A : never;
30
+ type ExtractListenerAdapterType<E> = E extends Listener<any, any, infer A, any> ? A : never;
31
+ type ExtractListenerHasParams<E> = E extends Listener<any, any, any, infer P> ? P : never;
32
+
33
+ type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0], unsubscribe: () => void) => void;
34
+
35
+ declare class Emitter<Payload, Response, Endpoint extends string, AdapterType extends SocketAdapterType, MappedData = void, HasParams extends boolean = false, HasData extends boolean = false> {
36
+ readonly socket: Socket<AdapterType>;
37
+ readonly emitterOptions: EmitterOptionsType<Endpoint, AdapterType>;
17
38
  readonly dataMapper?: (data: Payload) => MappedData;
18
- readonly name: string;
39
+ readonly endpoint: Endpoint;
40
+ params?: ParamsType;
19
41
  timeout: number;
20
42
  data: Payload | null;
21
- options: ExtractEmitterOptionsType<Adapter>;
22
- constructor(socket: Socket<Adapter>, emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<Adapter>>, json?: Partial<Emitter<Payload, Response, Adapter, MappedData>>, dataMapper?: (data: Payload) => MappedData);
23
- setOptions(options: ExtractEmitterOptionsType<Adapter>): Emitter<Payload, Response, Adapter, MappedData>;
24
- setTimeout(timeout: number): Emitter<Payload, Response, Adapter, MappedData>;
25
- setData(data: Payload): Emitter<Payload, Response, Adapter, MappedData>;
26
- setDataMapper: <MapperData>(mapper: (data: Payload) => MapperData) => Emitter<Payload, Response, Adapter, MapperData>;
27
- clone<NewPayload = Payload, MapperData = MappedData>(config?: Partial<EmitterCloneOptionsType<NewPayload, ExtractEmitterOptionsType<Adapter>>>, mapper?: (data: NewPayload) => MapperData): Emitter<NewPayload, Response, Adapter, MapperData>;
28
- emit(options?: Partial<EmitterCloneOptionsType<Payload, ExtractEmitterOptionsType<Adapter>>>, ack?: (error: Error | null, response: Response) => void): string;
43
+ options: ExtractEmitterOptionsType<AdapterType>;
44
+ connections: Set<ConnectMethodType<AdapterType, Response>>;
45
+ constructor(socket: Socket<AdapterType>, emitterOptions: EmitterOptionsType<Endpoint, AdapterType>, json?: Partial<Emitter<Payload, Response, Endpoint, AdapterType, MappedData>>, dataMapper?: (data: Payload) => MappedData);
46
+ setOptions(options: ExtractEmitterOptionsType<AdapterType>): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, HasParams, HasData>;
47
+ setTimeout(timeout: number): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, HasParams, HasData>;
48
+ setData(data: Payload): Emitter<MappedData, Response, Endpoint, AdapterType, MappedData, HasParams, true>;
49
+ setDataMapper: <MapperData>(mapper: (data: Payload) => MapperData) => Emitter<Payload, Response, Endpoint, AdapterType, MapperData, HasParams, HasData>;
50
+ setParams(params: ExtractRouteParams<Endpoint>): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, true, HasData>;
51
+ /**
52
+ * Attach global logic to the received events
53
+ * @param callback
54
+ */
55
+ onData(callback: ConnectMethodType<AdapterType, Response>): this;
56
+ private paramsMapper;
57
+ clone<NewPayload = Payload, MapperData = MappedData, Params extends boolean = HasParams, Data extends boolean = HasData>(options?: Partial<EmitterOptionsType<Endpoint, AdapterType>> & {
58
+ params?: ParamsType;
59
+ data?: NewPayload;
60
+ }, mapper?: (data: NewPayload) => MapperData): Emitter<NewPayload, Response, Endpoint, AdapterType, MapperData, Params, Data>;
61
+ getAck: (ack?: EmitterAcknowledgeType<any, AdapterType>) => (response: {
62
+ data: any;
63
+ extra: any;
64
+ error: any;
65
+ }) => void;
66
+ emit: EmitType<this>;
29
67
  }
30
68
 
31
- type EmitterInstance = Emitter<any, any, any>;
32
- type EmitterOptionsType<AdditionalEmitterOptions> = {
33
- name: string;
69
+ type EmitterInstance = Emitter<any, any, any, SocketAdapterInstance, any, any, any>;
70
+ type EmitterOptionsType<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
71
+ endpoint: Endpoint;
34
72
  timeout?: number;
35
- options?: AdditionalEmitterOptions;
73
+ options?: ExtractEmitterOptionsType<AdapterType>;
74
+ };
75
+ type EmitterAcknowledgeType<Response, AdapterType extends SocketAdapterInstance> = (response: {
76
+ error: Error;
77
+ data: null;
78
+ extra: null;
79
+ } | {
80
+ error: null;
81
+ data: Response;
82
+ extra: ExtractSocketExtraType<AdapterType>;
83
+ }) => void;
84
+ type EmitDataType<Payload, HasData extends boolean> = HasData extends false ? {
85
+ data: Payload;
86
+ } : {
87
+ data?: never;
36
88
  };
37
- type EmitterCloneOptionsType<DataType, AdditionalEmitterOptions> = Partial<EmitterOptionsType<AdditionalEmitterOptions>> & {
38
- data: DataType;
89
+ type EmitParamsType<Params, HasData extends boolean> = HasData extends false ? Params extends NegativeTypes ? {
90
+ params?: never;
91
+ } : {
92
+ params: Params;
93
+ } : {
94
+ params?: never;
39
95
  };
96
+ type EmitRestType<Emitter extends EmitterInstance> = {
97
+ options?: Partial<EmitterOptionsType<ExtractEmitterEndpointType<Emitter>, ExtractEmitterAdapterType<Emitter>>>;
98
+ ack?: EmitterAcknowledgeType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterAdapterType<Emitter>>;
99
+ };
100
+ type EmitType<Emitter extends EmitterInstance> = ExtractEmitterHasDataType<Emitter> extends false ? (options: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> & EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitRestType<Emitter>) => string : ExtractRouteParams<ExtractEmitterEndpointType<Emitter>> extends NegativeTypes ? (options?: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> & EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitRestType<Emitter>) => string : ExtractEmitterHasParamsType<Emitter> extends false ? (options: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> & EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitRestType<Emitter>) => string : (options?: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> & EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitRestType<Emitter>) => string;
40
101
 
41
- declare class SocketAdapter<SocketType extends SocketInstance> {
42
- readonly socket: SocketType;
43
- adapter: WebSocket | EventSource | undefined;
44
- listeners: Map<string, Set<ListenerCallbackType>>;
102
+ type RemoveListenerCallbackType = () => void;
103
+ type ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
104
+ data: D;
105
+ extra: ExtractSocketExtraType<AdapterType>;
106
+ }) => void;
107
+ type SocketAdapterType<AdapterOptions extends Record<string, any> = never, AdapterExtra extends Record<string, any> = Record<never, never>, ListenerOptions extends Record<string, any> = never, EmitterOptions extends Record<string, any> = never> = (socket: Socket<SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>, DO_NOT_USE?: {
108
+ adapterOptions?: AdapterOptions;
109
+ adapterExtra?: AdapterExtra;
110
+ listenerOptions?: ListenerOptions;
111
+ emitterOptions?: EmitterOptions;
112
+ }) => {
45
113
  open: boolean;
46
- connecting: boolean;
47
- forceClosed: boolean;
48
114
  reconnectionAttempts: number;
49
- pingTimer: ReturnType<typeof setTimeout> | undefined;
50
- pongTimer: ReturnType<typeof setTimeout> | undefined;
51
- init: () => WebSocket | EventSource;
52
- logger: LoggerType;
53
- constructor(socket: SocketType);
54
- connect: () => void;
55
- disconnect: () => void;
56
- reconnect: () => boolean;
57
- clearTimers: () => void;
58
- sendEventMessage: (payload: WSMessageType) => void;
59
- heartbeat: () => void;
60
- removeListener: (event: string, callback: (data: any, event: MessageEvent<any>) => void) => boolean;
61
- listen: (listener: Pick<ListenerInstance, "name">, callback: (data: any, event: MessageEvent<any>) => void) => () => boolean;
62
- emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: MessageEvent<any>) => void) => Promise<void>;
63
- }
64
-
65
- type RemoveListenerCallbackType = () => void;
66
- type ListenerCallbackType<D = any> = (data: D, event: MessageEvent<D>) => void;
67
- type AdapterType = {
115
+ listeners: Map<string, Map<ListenerCallbackType<SocketAdapterInstance, any>, VoidFunction>>;
116
+ listen: (listener: Listener<any, any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>, callback: ListenerCallbackType<SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>, any>) => RemoveListenerCallbackType;
117
+ removeListener: (endpoint: string, callback: (...args: any) => void) => void;
118
+ emit: (eventMessageId: string, emitter: EmitterInstance, ack?: EmitterAcknowledgeType<any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>) => void;
68
119
  connecting: boolean;
69
- listeners: Map<string, Set<ListenerCallbackType>>;
70
- emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: any) => void) => void;
71
- listen: (listener: ListenerInstance, callback: ListenerCallbackType) => RemoveListenerCallbackType;
72
- removeListener: (name: string, callback: (...args: any) => void) => void;
73
120
  connect: () => void;
74
121
  reconnect: () => void;
75
122
  disconnect: () => void;
76
123
  };
124
+ type SocketAdapterInstance = SocketAdapterType<any, any, any, any>;
125
+ type ExtractSocketOptionsType<T> = T extends SocketAdapterType<infer O, any, any, any> ? O : never;
126
+ type ExtractSocketExtraType<T> = T extends SocketAdapterType<any, infer E, any, any> ? E : never;
127
+ type ExtractListenerOptionsType<T> = T extends SocketAdapterType<any, any, infer O, any> ? O : never;
128
+ type ExtractEmitterOptionsType<T> = T extends SocketAdapterType<any, any, any, infer E> ? E : never;
129
+ type ExtractUnionSocket<Adapter extends SocketAdapterInstance, Values extends {
130
+ adapterOptions?: any;
131
+ adapterExtra?: any;
132
+ listenerOptions?: any;
133
+ emitterOptions?: any;
134
+ }> = Extract<Adapter, SocketAdapterType<Values["adapterOptions"], Values["adapterExtra"], Values["listenerOptions"], Values["emitterOptions"]>> extends SocketAdapterInstance ? Extract<Adapter, SocketAdapterType<Values["adapterOptions"], Values["adapterExtra"], Values["listenerOptions"], Values["emitterOptions"]>> : never;
77
135
  type SSEAdapterOptionsType = {
78
136
  eventSourceInit?: EventSourceInit;
79
- reconnectTimeout?: number;
80
137
  };
81
138
  type WSAdapterOptionsType = {
82
139
  protocols?: string[];
83
140
  pingTimeout?: number;
84
141
  pongTimeout?: number;
85
- reconnectTimeout?: number;
86
142
  heartbeatMessage?: string;
87
143
  heartbeat?: boolean;
88
144
  };
89
145
  type WSMessageType = {
90
146
  id: string;
91
- name: string;
147
+ endpoint: string;
92
148
  data: string;
93
149
  };
150
+ type SocketData<D = any> = {
151
+ endpoint: string;
152
+ data: D;
153
+ };
154
+ type WebsocketAdapterType = SocketAdapterType<WSAdapterOptionsType, MessageEvent<SocketData>>;
155
+ type SSEAdapterType = SocketAdapterType<SSEAdapterOptionsType, MessageEvent<SocketData>>;
94
156
 
95
- declare const getAdapter: (socket: SocketInstance) => WebSocket | EventSource;
157
+ declare const getSocketUrl: (socket: SocketInstance) => string;
158
+ declare const getWebsocketAdapter: (socket: SocketInstance) => WebSocket;
159
+ declare const getSSEAdapter: (socket: SocketInstance) => EventSource;
96
160
 
97
- declare class Listener<Response, Adapter extends AdapterType> {
98
- readonly socket: Socket<Adapter>;
99
- readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<Adapter>>;
100
- readonly name: string;
101
- options?: ExtractListenerOptionsType<Adapter>;
102
- constructor(socket: Socket<Adapter>, listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<Adapter>>);
103
- setOptions(options: ExtractListenerOptionsType<Adapter>): Listener<Response, Adapter>;
104
- clone(config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<Adapter>>>): Listener<Response, Adapter>;
105
- listen(callback: ListenerCallbackType<Response>): readonly [() => void, ListenerCallbackType<Response>];
161
+ declare const getSocketAdapterBindings: <T extends SocketAdapterInstance>(socket: SocketInstance, defaults?: {
162
+ open?: boolean;
163
+ connecting?: boolean;
164
+ forceClosed?: boolean;
165
+ reconnectionAttempts?: number;
166
+ }) => {
167
+ open: boolean;
168
+ connecting: boolean;
169
+ reconnectionAttempts: number;
170
+ forceClosed: boolean;
171
+ onConnect: () => boolean;
172
+ onReconnect: (disconnect: () => void, connect: () => void) => boolean;
173
+ onDisconnect: () => boolean;
174
+ onListen: (listener: Pick<ListenerInstance, "endpoint">, callback: ListenerCallbackType<T, any>, unmount?: VoidFunction) => (() => void);
175
+ onEmit: (emitter: EmitterInstance) => boolean;
176
+ onOpen: () => void;
177
+ onClose: () => void;
178
+ onError: (event: Error) => void;
179
+ onEvent: (endpoint: string, response: any, resposeExtra: ExtractSocketExtraType<T>) => void;
180
+ listeners: Map<string, Map<ListenerCallbackType<T, any>, VoidFunction>>;
181
+ removeListener: (endpoint: string, callback: ListenerCallbackType<T, any>) => boolean;
182
+ };
183
+
184
+ declare class Listener<Response, Endpoint extends string, AdapterType extends SocketAdapterType, HasParams extends boolean = false> {
185
+ readonly socket: Socket<AdapterType>;
186
+ readonly listenerOptions?: ListenerOptionsType<Endpoint, AdapterType>;
187
+ readonly endpoint: Endpoint;
188
+ params?: ParamsType;
189
+ options?: ExtractListenerOptionsType<AdapterType>;
190
+ connections: Set<ConnectMethodType<AdapterType, Response>>;
191
+ constructor(socket: Socket<AdapterType>, listenerOptions?: ListenerOptionsType<Endpoint, AdapterType>);
192
+ setOptions(options: ExtractListenerOptionsType<AdapterType>): Listener<Response, Endpoint, AdapterType, HasParams>;
193
+ setParams(params: ExtractRouteParams<Endpoint>): Listener<Response, Endpoint, AdapterType, true>;
194
+ private paramsMapper;
195
+ /**
196
+ * Attach global logic to the received events
197
+ * @param callback
198
+ */
199
+ onData(callback: ConnectMethodType<AdapterType, Response>): this;
200
+ clone<Params extends boolean = HasParams>(options?: Partial<ListenerOptionsType<Endpoint, AdapterType>>): Listener<Response, Endpoint, AdapterType, Params>;
201
+ listen: ListenType<this, AdapterType>;
106
202
  }
107
203
 
108
- type ListenerInstance = Listener<any, any>;
109
- type ListenerOptionsType<SocketOptions> = {
110
- name: string;
111
- options?: SocketOptions;
204
+ type ListenerInstance = Listener<any, any, SocketAdapterInstance, any>;
205
+ type ListenerOptionsType<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
206
+ endpoint: Endpoint;
207
+ params?: ExtractRouteParams<Endpoint>;
208
+ options?: ExtractListenerOptionsType<AdapterType>;
112
209
  };
210
+ type ListenType<Listener extends ListenerInstance, Adapter extends SocketAdapterType> = (options: ExtractRouteParams<ExtractListenerEndpointType<Listener>> extends NegativeTypes ? {
211
+ callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
212
+ } : ExtractListenerHasParams<Listener> extends false ? {
213
+ params: ExtractRouteParams<ExtractListenerEndpointType<Listener>>;
214
+ callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
215
+ } : {
216
+ params?: never;
217
+ callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
218
+ }) => () => void;
113
219
 
114
- declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
115
- options: SocketAdapterOptionsType<Adapter>;
220
+ declare class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
221
+ options: SocketOptionsType<AdapterType>;
116
222
  emitter: EventEmitter;
117
223
  events: {
118
- emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
224
+ emitError: <ResponseType_1>(event: ResponseType_1) => void;
119
225
  emitOpen: () => void;
120
226
  emitClose: () => void;
121
227
  emitConnecting: () => void;
122
228
  emitReconnecting: (attempts: number) => void;
123
229
  emitReconnectingStop: (attempts: number) => void;
124
- emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
125
- emitListenerRemoveEvent: (name: string) => void;
230
+ emitListenerEvent: <ResponseType_2>(endpoint: string, { data, extra }: {
231
+ data: ResponseType_2;
232
+ extra: any;
233
+ }) => void;
234
+ emitListenerRemoveEvent: (endpoint: string) => void;
126
235
  emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
127
- onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
236
+ onError: (callback: <ResponseType_3>(event: ResponseType_3) => void) => VoidFunction;
128
237
  onOpen: (callback: () => void) => VoidFunction;
129
238
  onClose: (callback: () => void) => VoidFunction;
130
239
  onConnecting: (callback: () => void) => VoidFunction;
131
240
  onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
132
241
  onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
133
- onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
242
+ onListenerEvent: <ResponseType_4 = Event>(callback: ({ endpoint, data, extra, }: {
243
+ endpoint: string;
244
+ data: ResponseType_4;
245
+ extra: any;
246
+ }) => void) => VoidFunction;
134
247
  onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
135
- onListenerEventByName: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: (data: ExtractListenerResponseType<ListenerType>, event: MessageEvent<ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
136
- onListenerRemove: (callback: (name: string) => void) => VoidFunction;
137
- onListenerRemoveByName: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
138
- onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
248
+ onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: ({ endpoint, data, extra, }: {
249
+ endpoint: string;
250
+ data: ResponseType;
251
+ extra: any;
252
+ }) => void) => VoidFunction;
253
+ onListenerRemove: (callback: (endpoint: string) => void) => VoidFunction;
254
+ onListenerRemoveByEndpoint: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
255
+ onEmitterEventByEndpoint: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
139
256
  };
140
257
  url: string;
141
258
  reconnect: number;
@@ -144,14 +261,14 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
144
261
  queryParams?: QueryParamsType | string;
145
262
  debug: boolean;
146
263
  autoConnect: boolean;
147
- __onOpenCallbacks: OpenCallbackType<Socket<Adapter>, any>[];
148
- __onCloseCallbacks: CloseCallbackType<Socket<Adapter>, any>[];
149
- __onReconnectCallbacks: ReconnectCallbackType<Socket<Adapter>>[];
150
- __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<Adapter>>[];
151
- __onMessageCallbacks: MessageCallbackType<Socket<Adapter>, any>[];
264
+ __onOpenCallbacks: OpenCallbackType<Socket<AdapterType>>[];
265
+ __onCloseCallbacks: CloseCallbackType<Socket<AdapterType>>[];
266
+ __onReconnectCallbacks: ReconnectCallbackType<Socket<AdapterType>>[];
267
+ __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<AdapterType>>[];
268
+ __onMessageCallbacks: MessageCallbackType<Socket<AdapterType>, any>[];
152
269
  __onSendCallbacks: SendCallbackType<EmitterInstance>[];
153
- __onErrorCallbacks: ErrorCallbackType<Socket<Adapter>, any>[];
154
- adapter: Adapter;
270
+ __onErrorCallbacks: ErrorCallbackType<Socket<AdapterType>, any>[];
271
+ adapter: ReturnType<AdapterType>;
155
272
  loggerManager: LoggerManager;
156
273
  appManager: AppManager;
157
274
  queryParamsConfig?: QueryStringifyOptionsType;
@@ -160,7 +277,7 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
160
277
  * Method to stringify query params from objects.
161
278
  */
162
279
  queryParamsStringify: StringifyCallbackType;
163
- constructor(options: SocketAdapterOptionsType<Adapter>);
280
+ constructor(options: SocketOptionsType<AdapterType>);
164
281
  /**
165
282
  * This method enables the logger usage and display the logs in console
166
283
  */
@@ -172,7 +289,7 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
172
289
  /**
173
290
  * Set the new logger instance to the socket
174
291
  */
175
- setLogger: (callback: (socket: Socket<Adapter>) => LoggerManager) => this;
292
+ setLogger: (callback: (socket: Socket<AdapterType>) => LoggerManager) => this;
176
293
  /**
177
294
  * Set the new auth data to the socket
178
295
  */
@@ -189,31 +306,31 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
189
306
  * @param callback
190
307
  * @returns
191
308
  */
192
- onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<Adapter>, Event>): this;
309
+ onOpen(callback: OpenCallbackType<Socket<AdapterType>>): this;
193
310
  /**
194
311
  * Triggered when connection is closed
195
312
  * @param callback
196
313
  * @returns
197
314
  */
198
- onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<Adapter>, Event>): this;
315
+ onClose(callback: CloseCallbackType<Socket<AdapterType>>): this;
199
316
  /**
200
317
  * Triggered when connection is getting reconnected
201
318
  * @param callback
202
319
  * @returns
203
320
  */
204
- onReconnect(callback: ReconnectCallbackType<Socket<Adapter>>): this;
321
+ onReconnect(callback: ReconnectCallbackType<Socket<AdapterType>>): this;
205
322
  /**
206
323
  * Triggered when connection attempts are stopped
207
324
  * @param callback
208
325
  * @returns
209
326
  */
210
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<Adapter>>): this;
327
+ onReconnectStop(callback: ReconnectStopCallbackType<Socket<AdapterType>>): this;
211
328
  /**
212
329
  * Triggered when any message is received
213
330
  * @param callback
214
331
  * @returns
215
332
  */
216
- onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<Adapter>, Event>): this;
333
+ onMessage<Event = ExtractSocketExtraType<AdapterType>>(callback: MessageCallbackType<Socket<AdapterType>, Event>): this;
217
334
  /**
218
335
  * Triggered when any event is emitted
219
336
  * @param callback
@@ -225,14 +342,20 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
225
342
  * @param callback
226
343
  * @returns
227
344
  */
228
- onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<Adapter>, Event>): this;
345
+ onError<Event = ExtractSocketExtraType<AdapterType>>(callback: ErrorCallbackType<Socket<AdapterType>, Event>): this;
229
346
  /**
230
347
  * ********************
231
348
  * Interceptors
232
349
  * ********************
233
350
  */
234
351
  __modifySend: (emitter: EmitterInstance) => EmitterInstance;
235
- __modifyResponse: (response: MessageEvent) => MessageEvent<any>;
352
+ __modifyResponse: (data: {
353
+ data: any;
354
+ extra: ExtractSocketExtraType<AdapterType>;
355
+ }) => {
356
+ data: any;
357
+ extra: any;
358
+ };
236
359
  /**
237
360
  * ********************
238
361
  * Creators
@@ -243,37 +366,32 @@ declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
243
366
  * @param options
244
367
  * @returns
245
368
  */
246
- createListener: <Response_1>(options: ListenerOptionsType<Adapter>) => Listener<Response_1, Adapter>;
369
+ createListener: <Response_1>() => <Endpoint extends string>(options: ListenerOptionsType<Endpoint, AdapterType>) => Listener<Response_1, Endpoint, AdapterType, false>;
247
370
  /**
248
371
  * Create event emitter
249
372
  * @param options
250
373
  * @returns
251
374
  */
252
- createEmitter: <Payload, Response_1 = never>(options: EmitterOptionsType<Adapter>) => Emitter<Payload, Response_1, Adapter, void>;
375
+ createEmitter: <Payload, Response_1 = never>() => <Endpoint extends string>(options: EmitterOptionsType<Endpoint, AdapterType>) => Emitter<Payload, Response_1, Endpoint, AdapterType, void, false, false>;
253
376
  }
254
377
 
255
- type SocketInstance = Socket<any>;
256
- type SocketOptionsType<SocketAdapterType> = {
378
+ type SocketInstance = Socket<SocketAdapterInstance>;
379
+ type SocketOptionsType<AdapterType extends SocketAdapterInstance> = {
257
380
  url: string;
258
- adapter?: SocketAdapterType;
381
+ adapter?: AdapterType;
259
382
  auth?: QueryParamsType;
260
- queryParams?: QueryParamsType | string;
261
383
  reconnect?: number;
262
384
  reconnectTime?: number;
385
+ queryParams?: QueryParamsType | string;
263
386
  autoConnect?: boolean;
264
387
  queryParamsConfig?: QueryStringifyOptionsType;
265
388
  queryParamsStringify?: StringifyCallbackType;
389
+ adapterOptions?: ExtractSocketOptionsType<AdapterType>;
266
390
  };
267
- type SocketAdapterOptionsType<SocketAdapterType> = (SocketOptionsType<SocketAdapterType> & {
268
- isSSE: true;
269
- adapterOptions?: SSEAdapterOptionsType;
270
- }) | (SocketOptionsType<SocketAdapterType> & {
271
- adapterOptions?: WSAdapterOptionsType;
272
- });
273
391
  type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
274
392
  type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
275
- type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
276
- type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
393
+ type OpenCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
394
+ type CloseCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
277
395
  type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
278
396
  type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
279
397
  type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
@@ -287,36 +405,51 @@ declare const getReconnectingStopKey: () => string;
287
405
  declare const getListenerEventKey: () => string;
288
406
  declare const getListenerRemoveKey: () => string;
289
407
  declare const getEmitterEventKey: () => string;
290
- declare const getListenerRemoveByNameKey: (event: string) => string;
291
- declare const getListenerEventByNameKey: (event: string) => string;
292
- declare const getEmitterEventByNameKey: (event: string) => string;
293
- declare const interceptListener: <Socket extends SocketInstance>(interceptors: MessageCallbackType<Socket, MessageEvent<any>>[], response: MessageEvent, socket: Socket) => MessageEvent<any>;
408
+ declare const getListenerRemoveByEndpointKey: (event: string) => string;
409
+ declare const getListenerEventByEndpointKey: (event: string) => string;
410
+ declare const getEmitterEventByEndpointKey: (event: string) => string;
411
+ declare const interceptListener: <Socket extends SocketInstance>(interceptors: MessageCallbackType<Socket, any>[], data: {
412
+ data: any;
413
+ extra: any;
414
+ }, socket: Socket) => {
415
+ data: any;
416
+ extra: any;
417
+ };
294
418
  declare const interceptEmitter: <EmitterType extends EmitterInstance>(interceptors: SendCallbackType<EmitterType>[], emitter: EmitterType) => EmitterType;
295
419
 
296
- declare const getSocketEvents: (eventEmitter: EventEmitter) => {
297
- emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
420
+ declare const getSocketEvents: <T extends SocketAdapterInstance>(eventEmitter: EventEmitter) => {
421
+ emitError: <ResponseType_1>(event: ResponseType_1) => void;
298
422
  emitOpen: () => void;
299
423
  emitClose: () => void;
300
424
  emitConnecting: () => void;
301
425
  emitReconnecting: (attempts: number) => void;
302
426
  emitReconnectingStop: (attempts: number) => void;
303
- emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
304
- emitListenerRemoveEvent: (name: string) => void;
427
+ emitListenerEvent: <ResponseType_2>(endpoint: string, { data, extra }: {
428
+ data: ResponseType_2;
429
+ extra: ExtractSocketExtraType<T>;
430
+ }) => void;
431
+ emitListenerRemoveEvent: (endpoint: string) => void;
305
432
  emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
306
- onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
433
+ onError: (callback: <ResponseType_3>(event: ResponseType_3) => void) => VoidFunction;
307
434
  onOpen: (callback: () => void) => VoidFunction;
308
435
  onClose: (callback: () => void) => VoidFunction;
309
436
  onConnecting: (callback: () => void) => VoidFunction;
310
437
  onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
311
438
  onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
312
- onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
439
+ onListenerEvent: <ResponseType_4 = Event>(callback: ({ endpoint, data, extra, }: {
440
+ endpoint: string;
441
+ data: ResponseType_4;
442
+ extra: ExtractSocketExtraType<T>;
443
+ }) => void) => VoidFunction;
313
444
  onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
314
- onListenerEventByName: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: (data: ExtractListenerResponseType<ListenerType>, event: MessageEvent<ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
315
- onListenerRemove: (callback: (name: string) => void) => VoidFunction;
316
- onListenerRemoveByName: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
317
- onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
445
+ onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: ({ endpoint, data, extra, }: {
446
+ endpoint: string;
447
+ data: ResponseType;
448
+ extra: ExtractSocketExtraType<T>;
449
+ }) => void) => VoidFunction;
450
+ onListenerRemove: (callback: (endpoint: string) => void) => VoidFunction;
451
+ onListenerRemoveByEndpoint: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
452
+ onEmitterEventByEndpoint: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
318
453
  };
319
454
 
320
- type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
321
-
322
- export { AdapterType, CloseCallbackType, Emitter, EmitterCloneOptionsType, EmitterInstance, EmitterOptionsType, ErrorCallbackType, ExtractEmitterAdapterType, ExtractEmitterMappedDataType, ExtractEmitterOptionsType, ExtractEmitterPayloadType, ExtractEmitterResponseType, ExtractListenerAdapterType, ExtractListenerOptionsType, ExtractListenerResponseType, Listener, ListenerCallbackType, ListenerInstance, ListenerOptionsType, MessageCallbackType, OpenCallbackType, ReconnectCallbackType, ReconnectStopCallbackType, RemoveListenerCallbackType, SSEAdapterOptionsType, SendCallbackType, Socket, SocketAdapter, SocketAdapterOptionsType, SocketInstance, SocketOptionsType, TupleRestType, WSAdapterOptionsType, WSMessageType, getAdapter, getCloseKey, getConnectingKey, getEmitterEventByNameKey, getEmitterEventKey, getErrorKey, getListenerEventByNameKey, getListenerEventKey, getListenerRemoveByNameKey, getListenerRemoveKey, getOpenKey, getReconnectingKey, getReconnectingStopKey, getSocketEvents, interceptEmitter, interceptListener };
455
+ export { CloseCallbackType, ConnectMethodType, EmitDataType, EmitParamsType, EmitRestType, EmitType, Emitter, EmitterAcknowledgeType, EmitterInstance, EmitterOptionsType, ErrorCallbackType, ExtractEmitterAdapterType, ExtractEmitterEndpointType, ExtractEmitterHasDataType, ExtractEmitterHasParamsType, ExtractEmitterMappedDataType, ExtractEmitterOptionsType, ExtractEmitterPayloadType, ExtractEmitterResponseType, ExtractListenerAdapterType, ExtractListenerEndpointType, ExtractListenerHasParams, ExtractListenerOptionsType, ExtractListenerResponseType, ExtractSocketExtraType, ExtractSocketOptionsType, ExtractUnionSocket, ListenType, Listener, ListenerCallbackType, ListenerInstance, ListenerOptionsType, MessageCallbackType, OpenCallbackType, ReconnectCallbackType, ReconnectStopCallbackType, RemoveListenerCallbackType, SSEAdapterOptionsType, SSEAdapterType, SendCallbackType, Socket, SocketAdapterInstance, SocketAdapterType, SocketData, SocketInstance, SocketOptionsType, TupleRestType, WSAdapterOptionsType, WSMessageType, WebsocketAdapterType, getCloseKey, getConnectingKey, getEmitterEventByEndpointKey, getEmitterEventKey, getErrorKey, getListenerEventByEndpointKey, getListenerEventKey, getListenerRemoveByEndpointKey, getListenerRemoveKey, getOpenKey, getReconnectingKey, getReconnectingStopKey, getSSEAdapter, getSocketAdapterBindings, getSocketEvents, getSocketUrl, getWebsocketAdapter, interceptEmitter, interceptListener, sseAdapter, websocketAdapter };