@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/README.md +0 -9
- package/dist/index.cjs.js +852 -1
- package/dist/index.cjs.js.map +4 -4
- package/dist/index.d.ts +264 -131
- package/dist/index.esm.js +832 -1
- package/dist/index.esm.js.map +4 -4
- package/package.json +1 -1
- package/src/adapter/adapter.bindings.ts +158 -0
- package/src/adapter/adapter.sse.ts +127 -0
- package/src/adapter/adapter.types.ts +83 -11
- package/src/adapter/adapter.utils.ts +12 -7
- package/src/adapter/adapter.websocket.ts +187 -0
- package/src/adapter/index.ts +3 -1
- package/src/emitter/emitter.ts +103 -30
- package/src/emitter/emitter.types.ts +63 -8
- package/src/listener/listener.ts +62 -21
- package/src/listener/listener.types.ts +23 -4
- package/src/socket/socket.events.ts +44 -32
- package/src/socket/socket.ts +29 -28
- package/src/socket/socket.types.ts +8 -13
- package/src/socket/socket.utils.ts +7 -7
- package/src/types/connect.types.ts +6 -0
- package/src/types/extract.types.ts +11 -12
- package/src/types/index.ts +1 -0
- package/src/adapter/adapter.ts +0 -238
package/dist/index.d.ts
CHANGED
|
@@ -1,141 +1,258 @@
|
|
|
1
1
|
import * as _hyper_fetch_core from '@hyper-fetch/core';
|
|
2
|
-
import {
|
|
2
|
+
import { ParamsType, ExtractRouteParams, NegativeTypes, QueryParamsType, LoggerManager, AppManager, QueryStringifyOptionsType, StringifyCallbackType, SeverityType } from '@hyper-fetch/core';
|
|
3
3
|
import EventEmitter from 'events';
|
|
4
4
|
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
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
|
-
|
|
15
|
-
|
|
16
|
-
|
|
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
|
|
39
|
+
readonly endpoint: Endpoint;
|
|
40
|
+
params?: ParamsType;
|
|
19
41
|
timeout: number;
|
|
20
42
|
data: Payload | null;
|
|
21
|
-
options: ExtractEmitterOptionsType<
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
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<
|
|
33
|
-
|
|
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?:
|
|
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
|
|
38
|
-
|
|
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
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
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
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
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<
|
|
110
|
-
|
|
111
|
-
|
|
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<
|
|
115
|
-
options:
|
|
220
|
+
declare class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
|
|
221
|
+
options: SocketOptionsType<AdapterType>;
|
|
116
222
|
emitter: EventEmitter;
|
|
117
223
|
events: {
|
|
118
|
-
emitError: <ResponseType_1
|
|
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
|
|
125
|
-
|
|
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
|
|
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
|
|
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
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
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<
|
|
148
|
-
__onCloseCallbacks: CloseCallbackType<Socket<
|
|
149
|
-
__onReconnectCallbacks: ReconnectCallbackType<Socket<
|
|
150
|
-
__onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<
|
|
151
|
-
__onMessageCallbacks: MessageCallbackType<Socket<
|
|
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<
|
|
154
|
-
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:
|
|
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<
|
|
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
|
|
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
|
|
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<
|
|
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<
|
|
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 =
|
|
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 =
|
|
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: (
|
|
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<
|
|
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<
|
|
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<
|
|
256
|
-
type SocketOptionsType<
|
|
378
|
+
type SocketInstance = Socket<SocketAdapterInstance>;
|
|
379
|
+
type SocketOptionsType<AdapterType extends SocketAdapterInstance> = {
|
|
257
380
|
url: string;
|
|
258
|
-
adapter?:
|
|
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
|
|
276
|
-
type CloseCallbackType<SocketType extends SocketInstance
|
|
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
|
|
291
|
-
declare const
|
|
292
|
-
declare const
|
|
293
|
-
declare const interceptListener: <Socket extends SocketInstance>(interceptors: MessageCallbackType<Socket,
|
|
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
|
|
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
|
|
304
|
-
|
|
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
|
|
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
|
|
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
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
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
|
-
|
|
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 };
|