@hyper-fetch/sockets 6.0.1 → 7.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.eslintrc.json +8 -3
- package/README.md +6 -6
- package/dist/index.d.ts +523 -296
- package/dist/index.js +1246 -0
- package/dist/index.js.map +7 -0
- package/package.json +8 -9
- package/src/adapter/adapter.bindings.ts +128 -101
- package/src/adapter/adapter.ts +231 -0
- package/src/adapter/adapter.types.ts +10 -101
- package/src/adapter/index.ts +4 -4
- package/src/adapter-sse/index.ts +3 -0
- package/src/adapter-sse/sse-adapter.ts +192 -0
- package/src/adapter-sse/sse-adapter.types.ts +6 -0
- package/src/adapter-sse/sse-adapter.utils.ts +77 -0
- package/src/adapter-websockets/index.ts +3 -0
- package/src/adapter-websockets/websocket-adapter.ts +259 -0
- package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
- package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
- package/src/emitter/emitter.ts +60 -102
- package/src/emitter/emitter.types.ts +82 -49
- package/src/index.ts +3 -0
- package/src/listener/listener.ts +34 -49
- package/src/listener/listener.types.ts +69 -17
- package/src/socket/socket.events.ts +147 -112
- package/src/socket/socket.ts +78 -100
- package/src/socket/socket.types.ts +13 -18
- package/src/socket/socket.utils.ts +12 -14
- package/src/types/connect.types.ts +2 -2
- package/src/types/extract.types.ts +43 -10
- package/src/utils/index.ts +3 -0
- package/src/utils/message-event.utils.ts +6 -0
- package/src/utils/socket.errors.ts +48 -0
- package/src/utils/socket.utils.ts +4 -0
- package/tsconfig.json +7 -3
- package/dist/index.cjs.js +0 -853
- package/dist/index.cjs.js.map +0 -7
- package/dist/index.esm.js +0 -833
- package/dist/index.esm.js.map +0 -7
- package/src/adapter/adapter.sse.ts +0 -127
- package/src/adapter/adapter.utils.ts +0 -20
- package/src/adapter/adapter.websocket.ts +0 -187
package/dist/index.d.ts
CHANGED
|
@@ -1,303 +1,406 @@
|
|
|
1
1
|
import * as _hyper_fetch_core from '@hyper-fetch/core';
|
|
2
|
-
import { ParamsType, ExtractRouteParams,
|
|
2
|
+
import { ParamsType, PayloadMapperType, EmptyTypes, ExtractRouteParams, TypeWithDefaults, QueryParamsType, QueryParamsMapper, DefaultMapperType, QueryStringifyOptionsType, stringifyQueryParams, LoggerManager, AppManager, LogLevel } from '@hyper-fetch/core';
|
|
3
3
|
import EventEmitter from 'events';
|
|
4
4
|
|
|
5
|
-
/**
|
|
6
|
-
* -------------------------------------------
|
|
7
|
-
* Websocket
|
|
8
|
-
* -------------------------------------------
|
|
9
|
-
*/
|
|
10
|
-
declare const websocketAdapter: WebsocketAdapterType;
|
|
11
|
-
|
|
12
|
-
/**
|
|
13
|
-
* -------------------------------------------
|
|
14
|
-
* Websocket
|
|
15
|
-
* -------------------------------------------
|
|
16
|
-
*/
|
|
17
|
-
declare const sseAdapter: SSEAdapterType;
|
|
18
|
-
|
|
19
5
|
type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
|
|
20
6
|
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
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>;
|
|
38
|
-
readonly dataMapper?: (data: Payload) => MappedData;
|
|
39
|
-
readonly endpoint: Endpoint;
|
|
7
|
+
declare class Emitter<Payload, Topic extends string, Socket extends SocketInstance, HasPayload extends boolean = false, HasParams extends boolean = false> {
|
|
8
|
+
readonly socket: Socket;
|
|
9
|
+
readonly emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>;
|
|
10
|
+
readonly topic: Topic;
|
|
40
11
|
params?: ParamsType;
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
constructor(socket: Socket
|
|
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>;
|
|
12
|
+
payload: Payload | undefined;
|
|
13
|
+
options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined;
|
|
14
|
+
/** @internal */
|
|
15
|
+
unstable_payloadMapper?: PayloadMapperType<any>;
|
|
16
|
+
constructor(socket: Socket, emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>,
|
|
51
17
|
/**
|
|
52
|
-
*
|
|
53
|
-
* @
|
|
18
|
+
* Used to recreate the emitter with the same state
|
|
19
|
+
* @internal
|
|
54
20
|
*/
|
|
55
|
-
|
|
21
|
+
snapshot?: Partial<Emitter<Payload, Topic, Socket, any, any>>);
|
|
22
|
+
setOptions(options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined): Emitter<Payload, Topic, Socket, HasPayload, HasParams>;
|
|
23
|
+
setPayload: <D extends Payload>(payload: D) => Emitter<D, Topic, Socket, D extends EmptyTypes ? false : true, HasParams>;
|
|
24
|
+
setPayloadMapper: <DataMapper extends (payload: Payload) => any | Promise<any>>(payloadMapper: DataMapper) => Emitter<Payload, Topic, Socket, HasPayload, HasParams>;
|
|
25
|
+
setParams(params: NonNullable<ExtractRouteParams<Topic>>): Emitter<Payload, Topic, Socket, HasPayload, true>;
|
|
56
26
|
private paramsMapper;
|
|
57
|
-
clone<NewPayload
|
|
58
|
-
|
|
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>;
|
|
27
|
+
clone<NewPayload extends Payload = Payload, NewHasPayload extends boolean = HasPayload, NewHasParams extends boolean = HasParams>(config?: EmitterCloneOptionsType<NewPayload, ParamsType, Topic, Socket>): Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>;
|
|
28
|
+
emit: EmitType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>>;
|
|
67
29
|
}
|
|
68
30
|
|
|
69
|
-
type
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
31
|
+
type EmitterInstanceProperties = {
|
|
32
|
+
payload?: any;
|
|
33
|
+
topic?: string;
|
|
34
|
+
socket?: SocketInstance;
|
|
35
|
+
hasParams?: boolean;
|
|
36
|
+
hasPayload?: boolean;
|
|
37
|
+
};
|
|
38
|
+
type EmitterInstance<EmitterProperties extends EmitterInstanceProperties = {}> = Emitter<TypeWithDefaults<EmitterProperties, "payload", any>, TypeWithDefaults<EmitterProperties, "topic", any>, TypeWithDefaults<EmitterProperties, "socket", SocketInstance>, TypeWithDefaults<EmitterProperties, "hasPayload", any>, TypeWithDefaults<EmitterProperties, "hasParams", any>>;
|
|
39
|
+
type EmitterCloneOptionsType<Payload, Params, Topic extends string, Socket extends SocketInstance> = {
|
|
40
|
+
payload?: Payload;
|
|
41
|
+
params?: Params | null;
|
|
42
|
+
} & Partial<EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
|
|
43
|
+
type EmitterOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
|
|
44
|
+
topic: Topic;
|
|
45
|
+
options?: ExtractAdapterEmitterOptionsType<AdapterType>;
|
|
74
46
|
};
|
|
75
|
-
type
|
|
47
|
+
type EmitterCallbackErrorType = (data: {
|
|
76
48
|
error: Error;
|
|
77
|
-
data: null;
|
|
78
|
-
extra: null;
|
|
79
|
-
} | {
|
|
80
|
-
error: null;
|
|
81
|
-
data: Response;
|
|
82
|
-
extra: ExtractSocketExtraType<AdapterType>;
|
|
83
49
|
}) => void;
|
|
84
|
-
type
|
|
85
|
-
|
|
50
|
+
type EmitPayloadType<Payload, HasPayload extends boolean> = HasPayload extends false ? {
|
|
51
|
+
payload: Payload;
|
|
86
52
|
} : {
|
|
87
|
-
|
|
53
|
+
payload?: Payload;
|
|
88
54
|
};
|
|
89
|
-
type EmitParamsType<Params,
|
|
90
|
-
params?:
|
|
55
|
+
type EmitParamsType<Params extends ParamsType | EmptyTypes, HasPayload extends boolean> = HasPayload extends false ? Params extends EmptyTypes ? {
|
|
56
|
+
params?: Params;
|
|
91
57
|
} : {
|
|
92
58
|
params: Params;
|
|
93
59
|
} : {
|
|
94
|
-
params?:
|
|
60
|
+
params?: Params;
|
|
95
61
|
};
|
|
96
|
-
type
|
|
97
|
-
options?:
|
|
98
|
-
|
|
62
|
+
type EmitterRestParams<Adapter extends SocketAdapterInstance> = ExtractAdapterEmitterOptionsType<Adapter> extends any ? {} : ExtractAdapterEmitterOptionsType<Adapter> extends Record<string, any> ? {
|
|
63
|
+
options?: ExtractAdapterEmitterOptionsType<Adapter>;
|
|
64
|
+
} : {};
|
|
65
|
+
type EmitMethodOptionsType<Emitter extends EmitterInstance> = EmitPayloadType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasPayloadType<Emitter>> & EmitParamsType<ExtractRouteParams<ExtractEmitterTopicType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> & EmitterRestParams<ExtractSocketAdapterType<ExtractEmitterSocketType<Emitter>>>;
|
|
66
|
+
type EmitType<Emitter extends EmitterInstance> = ExtractEmitterHasPayloadType<Emitter> extends false ? (options: EmitMethodOptionsType<Emitter>) => void : ExtractRouteParams<ExtractEmitterTopicType<Emitter>> extends EmptyTypes ? (options?: EmitMethodOptionsType<Emitter>) => void : ExtractEmitterHasParamsType<Emitter> extends false ? (options: EmitMethodOptionsType<Emitter>) => void : (options?: EmitMethodOptionsType<Emitter>) => void;
|
|
67
|
+
type ExtendEmitter<T extends EmitterInstance, Properties extends {
|
|
68
|
+
payload?: any;
|
|
69
|
+
response?: any;
|
|
70
|
+
topic?: string;
|
|
71
|
+
socket?: SocketInstance;
|
|
72
|
+
mappedData?: any;
|
|
73
|
+
hasData?: true | false;
|
|
74
|
+
hasParams?: true | false;
|
|
75
|
+
}> = Emitter<TypeWithDefaults<Properties, "payload", ExtractEmitterPayloadType<T>>, Properties["topic"] extends string ? Properties["topic"] : ExtractEmitterTopicType<T>, Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractEmitterSocketType<T>, Properties["hasData"] extends true ? true : ExtractEmitterHasPayloadType<T>, Properties["hasParams"] extends true ? true : ExtractEmitterHasParamsType<T>>;
|
|
76
|
+
|
|
77
|
+
declare const getAdapterBindings: <T extends SocketAdapterInstance>(socket: Socket<T>) => {
|
|
78
|
+
socket: Socket<T>;
|
|
79
|
+
adapter: T;
|
|
80
|
+
logger: _hyper_fetch_core.LoggerMethods;
|
|
81
|
+
getQueryParams: () => any;
|
|
82
|
+
onConnect: () => boolean;
|
|
83
|
+
onReconnect: ({ disconnect, connect, }: {
|
|
84
|
+
disconnect: () => Promise<any>;
|
|
85
|
+
connect: () => Promise<any>;
|
|
86
|
+
}) => Promise<boolean>;
|
|
87
|
+
onDisconnect: () => boolean;
|
|
88
|
+
onListen: ({ listener, callback, onUnmount, }: {
|
|
89
|
+
listener: Pick<ListenerInstance, "topic">;
|
|
90
|
+
callback: ListenerCallbackType<T, any>;
|
|
91
|
+
onUnmount?: VoidFunction;
|
|
92
|
+
}) => (() => void);
|
|
93
|
+
onEmit: ({ emitter }: {
|
|
94
|
+
emitter: EmitterInstance;
|
|
95
|
+
}) => Promise<EmitterInstance | null>;
|
|
96
|
+
onEmitError: <ErrorType extends Error>({ emitter, error }: {
|
|
97
|
+
emitter: EmitterInstance;
|
|
98
|
+
error: ErrorType;
|
|
99
|
+
}) => void;
|
|
100
|
+
onConnected: () => void;
|
|
101
|
+
onDisconnected: () => void;
|
|
102
|
+
onError: ({ error }: {
|
|
103
|
+
error: Error;
|
|
104
|
+
}) => void;
|
|
105
|
+
onEvent: ({ topic, data, extra }: {
|
|
106
|
+
topic: string;
|
|
107
|
+
data: any;
|
|
108
|
+
extra: ExtractAdapterExtraType<T>;
|
|
109
|
+
}) => void;
|
|
99
110
|
};
|
|
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;
|
|
101
111
|
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
112
|
+
declare class SocketAdapter<Extra = undefined, AdapterOptions extends Record<string, any> | EmptyTypes = undefined, ListenerOptions extends Record<string, any> | EmptyTypes = undefined, EmitterOptions extends Record<string, any> | EmptyTypes = undefined, QueryParams extends QueryParamsType | string | EmptyTypes = undefined, QueryParamsMapperType extends QueryParamsMapper<any> | DefaultMapperType = DefaultMapperType> {
|
|
113
|
+
options: {
|
|
114
|
+
name: string;
|
|
115
|
+
queryParams?: QueryParams;
|
|
116
|
+
defaultConnected?: boolean;
|
|
117
|
+
defaultConnecting?: boolean;
|
|
118
|
+
defaultReconnectionAttempts?: number;
|
|
119
|
+
defaultForceClosed?: boolean;
|
|
120
|
+
};
|
|
121
|
+
name: string;
|
|
122
|
+
socket: SocketInstance;
|
|
123
|
+
defaultExtra?: Extra;
|
|
124
|
+
queryParams?: QueryParams;
|
|
125
|
+
queryParamsConfig?: QueryStringifyOptionsType;
|
|
126
|
+
/** Config for the query params mapper */
|
|
127
|
+
unstable_queryParamsMapperConfig: Parameters<QueryParamsMapperType>[1];
|
|
128
|
+
/** Method to get request data and transform them to the required format. */
|
|
129
|
+
unstable_queryParamsMapper: QueryParamsMapperType;
|
|
130
|
+
adapterOptions: AdapterOptions | EmptyTypes;
|
|
131
|
+
listenerOptions: ListenerOptions | EmptyTypes;
|
|
132
|
+
emitterOptions: EmitterOptions | EmptyTypes;
|
|
133
|
+
private getConnector;
|
|
134
|
+
connected: boolean;
|
|
119
135
|
connecting: boolean;
|
|
136
|
+
reconnectionAttempts: number;
|
|
137
|
+
forceClosed: boolean;
|
|
138
|
+
listeners: Map<string, Map<ListenerCallbackType<this, any>, VoidFunction>>;
|
|
139
|
+
listen: (listener: ListenerInstance, callback: ListenerCallbackType<this, any>) => RemoveListenerCallbackType;
|
|
140
|
+
emit: (emitter: EmitterInstance) => void;
|
|
120
141
|
connect: () => void;
|
|
121
142
|
reconnect: () => void;
|
|
122
143
|
disconnect: () => void;
|
|
144
|
+
constructor(options: {
|
|
145
|
+
name: string;
|
|
146
|
+
queryParams?: QueryParams;
|
|
147
|
+
defaultConnected?: boolean;
|
|
148
|
+
defaultConnecting?: boolean;
|
|
149
|
+
defaultReconnectionAttempts?: number;
|
|
150
|
+
defaultForceClosed?: boolean;
|
|
151
|
+
});
|
|
152
|
+
initialize(socket: SocketInstance): this;
|
|
153
|
+
setQueryParams(queryParams: QueryParams): this;
|
|
154
|
+
setQueryParamsConfig(queryParamsConfig: QueryStringifyOptionsType): this;
|
|
155
|
+
setDefaultExtra(defaultExtra: Extra): this;
|
|
156
|
+
setOptions(adapterOptions: AdapterOptions | EmptyTypes): this;
|
|
157
|
+
setDefaultListenerOptions(listenerOptions: ListenerOptions | EmptyTypes): this;
|
|
158
|
+
setDefaultEmitterOptions(emitterOptions: EmitterOptions | EmptyTypes): this;
|
|
159
|
+
setQueryParamsMapperConfig: <NewQueryParamsMapperConfig extends Parameters<QueryParamsMapperType>[1]>(config: NewQueryParamsMapperConfig) => this;
|
|
160
|
+
/**
|
|
161
|
+
* Set the query params mapping function which get triggered before request get sent
|
|
162
|
+
*/
|
|
163
|
+
setQueryParamsMapper: <NewQueryParamsMapper extends QueryParamsMapper<QueryParams>>(queryParamsMapper: NewQueryParamsMapper) => SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, NewQueryParamsMapper>;
|
|
164
|
+
removeListener: ({ topic, callback, }: {
|
|
165
|
+
topic: string;
|
|
166
|
+
callback: ListenerCallbackType<SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>, any>;
|
|
167
|
+
}) => boolean;
|
|
168
|
+
triggerListeners: ({ topic, data, extra, }: {
|
|
169
|
+
topic: string;
|
|
170
|
+
data: any;
|
|
171
|
+
extra: ExtractAdapterExtraType<SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>>;
|
|
172
|
+
}) => void;
|
|
173
|
+
setConnected: (connected: boolean) => this;
|
|
174
|
+
setConnecting: (connecting: boolean) => this;
|
|
175
|
+
setReconnectionAttempts: (reconnectionAttempts: number) => this;
|
|
176
|
+
setForceClosed: (forceClosed: boolean) => this;
|
|
177
|
+
setConnector: (connector: (bindings: ReturnType<typeof getAdapterBindings<this>>) => Connector) => this;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
type RemoveListenerCallbackType = () => void;
|
|
181
|
+
type SocketAdapterInstance = SocketAdapter<any, any, any, any, any, any>;
|
|
182
|
+
type Connector = {
|
|
183
|
+
connect: () => void;
|
|
184
|
+
reconnect: () => void;
|
|
185
|
+
disconnect: () => void;
|
|
186
|
+
listen: (listener: ListenerInstance, callback: ListenerCallbackType<SocketAdapterInstance, any>) => RemoveListenerCallbackType;
|
|
187
|
+
emit: (emitter: EmitterInstance) => void;
|
|
123
188
|
};
|
|
124
|
-
|
|
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;
|
|
135
|
-
type SSEAdapterOptionsType = {
|
|
136
|
-
eventSourceInit?: EventSourceInit;
|
|
137
|
-
};
|
|
138
|
-
type WSAdapterOptionsType = {
|
|
139
|
-
protocols?: string[];
|
|
140
|
-
pingTimeout?: number;
|
|
141
|
-
pongTimeout?: number;
|
|
142
|
-
heartbeatMessage?: string;
|
|
143
|
-
heartbeat?: boolean;
|
|
144
|
-
};
|
|
145
|
-
type WSMessageType = {
|
|
146
|
-
id: string;
|
|
147
|
-
endpoint: string;
|
|
148
|
-
data: string;
|
|
149
|
-
};
|
|
189
|
+
|
|
150
190
|
type SocketData<D = any> = {
|
|
151
|
-
|
|
152
|
-
|
|
191
|
+
topic: string;
|
|
192
|
+
payload: D;
|
|
153
193
|
};
|
|
154
|
-
type WebsocketAdapterType = SocketAdapterType<WSAdapterOptionsType, MessageEvent<SocketData>>;
|
|
155
|
-
type SSEAdapterType = SocketAdapterType<SSEAdapterOptionsType, MessageEvent<SocketData>>;
|
|
156
|
-
|
|
157
|
-
declare const getSocketUrl: (socket: SocketInstance) => string;
|
|
158
|
-
declare const getWebsocketAdapter: (socket: SocketInstance) => WebSocket;
|
|
159
|
-
declare const getSSEAdapter: (socket: SocketInstance) => EventSource;
|
|
160
194
|
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
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;
|
|
195
|
+
type EventReturnType<GenericDataType, Adapter extends SocketAdapterInstance> = {
|
|
196
|
+
data: GenericDataType;
|
|
197
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
182
198
|
};
|
|
199
|
+
type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any> ? P : never;
|
|
200
|
+
type ExtractEmitterTopicType<E> = E extends Emitter<any, infer T, any, any, any> ? T : never;
|
|
201
|
+
type ExtractEmitterSocketType<E> = E extends Emitter<any, any, infer A, any, any> ? A : never;
|
|
202
|
+
type ExtractEmitterHasPayloadType<E> = E extends Emitter<any, any, any, infer D, any> ? D : never;
|
|
203
|
+
type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, infer P> ? P : never;
|
|
204
|
+
type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
|
|
205
|
+
type ExtractListenerTopicType<E> = E extends Listener<any, infer T, any, any> ? T : never;
|
|
206
|
+
type ExtractListenerSocketType<E> = E extends Listener<any, any, infer A, any> ? A : never;
|
|
207
|
+
type ExtractListenerHasParamsType<E> = E extends Listener<any, any, any, infer P> ? P : never;
|
|
208
|
+
type ExtractSocketAdapterType<T extends SocketInstance> = T extends Socket<infer Adapter> ? Adapter : never;
|
|
209
|
+
type ExtractSocketOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterOptionsType<Adapter> : never;
|
|
210
|
+
type ExtractSocketExtraType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterExtraType<Adapter> : never;
|
|
211
|
+
type ExtractListenerOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterListenerOptionsType<Adapter> : never;
|
|
212
|
+
type ExtractEmitterOptionsType<T extends SocketInstance> = T extends Socket<infer Adapter> ? ExtractAdapterEmitterOptionsType<Adapter> : never;
|
|
213
|
+
type ExtractAdapterExtraType<T extends SocketAdapterInstance> = T extends SocketAdapter<infer P, any, any, any, any, any> ? P : never;
|
|
214
|
+
type ExtractAdapterOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, infer P, any, any, any, any> ? P : never;
|
|
215
|
+
type ExtractAdapterListenerOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, infer P, any, any, any> ? P : never;
|
|
216
|
+
type ExtractAdapterEmitterOptionsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, infer P, any, any> ? P : never;
|
|
217
|
+
type ExtractAdapterQueryParamsType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, any, infer P, any> ? P : never;
|
|
218
|
+
type ExtractAdapterQueryParamsMapperType<T extends SocketAdapterInstance> = T extends SocketAdapter<any, any, any, any, any, infer P> ? P : never;
|
|
219
|
+
|
|
220
|
+
type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0]) => void;
|
|
183
221
|
|
|
184
|
-
declare class Listener<Response,
|
|
185
|
-
readonly socket: Socket
|
|
186
|
-
readonly listenerOptions
|
|
187
|
-
readonly
|
|
222
|
+
declare class Listener<Response, Topic extends string, Socket extends SocketInstance, HasParams extends boolean = false> {
|
|
223
|
+
readonly socket: Socket;
|
|
224
|
+
readonly listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>;
|
|
225
|
+
readonly topic: Topic;
|
|
188
226
|
params?: ParamsType;
|
|
189
|
-
options?:
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
227
|
+
options?: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>;
|
|
228
|
+
constructor(socket: Socket, listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>);
|
|
229
|
+
setOptions(options: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>): Listener<Response, Topic, Socket, HasParams>;
|
|
230
|
+
setParams(params: ExtractRouteParams<Topic>): Listener<Response, Topic, Socket, true>;
|
|
231
|
+
clone<NewHasParams extends true | false = HasParams>(options?: ListenerConfigurationType<ExtractRouteParams<Topic>, Topic, Socket>): Listener<Response, Topic, Socket, NewHasParams>;
|
|
232
|
+
listen: ListenType<Listener<Response, Topic, Socket, HasParams>, Socket>;
|
|
194
233
|
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>;
|
|
202
234
|
}
|
|
203
235
|
|
|
204
|
-
type
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
236
|
+
type ListenerInstanceProperties = {
|
|
237
|
+
response?: any;
|
|
238
|
+
topic?: string;
|
|
239
|
+
socket?: SocketInstance;
|
|
240
|
+
hasParams?: boolean;
|
|
209
241
|
};
|
|
210
|
-
type
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
242
|
+
type ListenerInstance<ListenerProperties extends ListenerInstanceProperties = {}> = Listener<TypeWithDefaults<ListenerProperties, "response", any>, TypeWithDefaults<ListenerProperties, "topic", any>, TypeWithDefaults<ListenerProperties, "socket", SocketInstance>, TypeWithDefaults<ListenerProperties, "hasParams", any>>;
|
|
243
|
+
type ListenerOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
|
|
244
|
+
topic: Topic;
|
|
245
|
+
options?: ExtractAdapterListenerOptionsType<AdapterType>;
|
|
246
|
+
};
|
|
247
|
+
type ListenerConfigurationType<Params, Topic extends string, Socket extends SocketInstance> = {
|
|
248
|
+
params?: Params;
|
|
249
|
+
} & Partial<ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
|
|
250
|
+
type ListenerParamsOptionsType<Listener extends ListenerInstance> = ExtractListenerHasParamsType<Listener> extends false ? {
|
|
251
|
+
params: ExtractRouteParams<ExtractListenerTopicType<Listener>>;
|
|
215
252
|
} : {
|
|
216
253
|
params?: never;
|
|
217
|
-
|
|
218
|
-
|
|
254
|
+
};
|
|
255
|
+
type ListenType<Listener extends ListenerInstance, Socket extends SocketInstance> = ExtractRouteParams<ExtractListenerTopicType<Listener>> extends EmptyTypes ? (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void : ExtractListenerHasParamsType<Listener> extends true ? (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void : (callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>) => () => void;
|
|
256
|
+
type ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
|
|
257
|
+
data: D;
|
|
258
|
+
extra: ExtractAdapterExtraType<AdapterType>;
|
|
259
|
+
}) => void;
|
|
260
|
+
type ExtendListener<T extends ListenerInstance, Properties extends {
|
|
261
|
+
response?: any;
|
|
262
|
+
topic?: string;
|
|
263
|
+
socket?: SocketInstance;
|
|
264
|
+
hasParams?: true | false;
|
|
265
|
+
}> = Listener<TypeWithDefaults<Properties, "response", ExtractListenerResponseType<T>>, Properties["topic"] extends string ? Properties["topic"] : ExtractListenerTopicType<T>, Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractListenerSocketType<T>, Properties["hasParams"] extends true ? true : ExtractListenerHasParamsType<T>>;
|
|
219
266
|
|
|
220
|
-
|
|
221
|
-
|
|
267
|
+
type WebsocketAdapterOptionsType = {
|
|
268
|
+
protocols?: string[];
|
|
269
|
+
pingTimeout?: number;
|
|
270
|
+
pongTimeout?: number;
|
|
271
|
+
heartbeatMessage?: string;
|
|
272
|
+
heartbeat?: boolean;
|
|
273
|
+
autoConnect?: boolean;
|
|
274
|
+
};
|
|
275
|
+
|
|
276
|
+
/**
|
|
277
|
+
* -------------------------------------------
|
|
278
|
+
* Websocket
|
|
279
|
+
* -------------------------------------------
|
|
280
|
+
*/
|
|
281
|
+
type WebsocketAdapterType = SocketAdapter<MessageEvent<any>, WebsocketAdapterOptionsType, undefined, undefined, QueryParamsType | string, typeof stringifyQueryParams>;
|
|
282
|
+
declare const WebsocketAdapter: () => WebsocketAdapterType;
|
|
283
|
+
|
|
284
|
+
declare class Socket<Adapter extends SocketAdapterInstance = WebsocketAdapterType> {
|
|
285
|
+
options: SocketOptionsType<Adapter>;
|
|
222
286
|
emitter: EventEmitter;
|
|
223
287
|
events: {
|
|
224
|
-
emitError: <
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
288
|
+
readonly emitError: <ResponseType>({ error }: {
|
|
289
|
+
error: ResponseType;
|
|
290
|
+
}) => void;
|
|
291
|
+
readonly emitConnected: () => void;
|
|
292
|
+
readonly emitDisconnected: () => void;
|
|
293
|
+
readonly emitConnecting: ({ connecting }: {
|
|
294
|
+
connecting: boolean;
|
|
295
|
+
}) => void;
|
|
296
|
+
readonly emitReconnecting: ({ attempts }: {
|
|
297
|
+
attempts: number;
|
|
298
|
+
}) => void;
|
|
299
|
+
readonly emitReconnectingFailed: ({ attempts }: {
|
|
300
|
+
attempts: number;
|
|
301
|
+
}) => void;
|
|
302
|
+
readonly emitListenerEvent: <ResponseType>({ topic, data, extra, }: {
|
|
303
|
+
topic: string;
|
|
304
|
+
data: ResponseType;
|
|
232
305
|
extra: any;
|
|
233
306
|
}) => void;
|
|
234
|
-
emitListenerRemoveEvent: (
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
307
|
+
readonly emitListenerRemoveEvent: ({ topic }: {
|
|
308
|
+
topic: string;
|
|
309
|
+
}) => void;
|
|
310
|
+
readonly emitEmitterStartEvent: <EmitterType extends EmitterInstance>({ emitter }: {
|
|
311
|
+
emitter: EmitterType;
|
|
312
|
+
}) => void;
|
|
313
|
+
readonly emitEmitterError: <EmitterType extends EmitterInstance>({ error, emitter, }: {
|
|
314
|
+
error: Error;
|
|
315
|
+
emitter: EmitterType;
|
|
316
|
+
}) => void;
|
|
317
|
+
readonly onError: (callback: <ResponseType>({ error }: {
|
|
318
|
+
error: ResponseType;
|
|
319
|
+
}) => void) => VoidFunction;
|
|
320
|
+
readonly onConnected: (callback: () => void) => VoidFunction;
|
|
321
|
+
readonly onDisconnected: (callback: () => void) => VoidFunction;
|
|
322
|
+
readonly onConnecting: (callback: ({ connecting }: {
|
|
323
|
+
connecting: boolean;
|
|
324
|
+
}) => void) => VoidFunction;
|
|
325
|
+
readonly onReconnecting: (callback: ({ attempts }: {
|
|
326
|
+
attempts: number;
|
|
327
|
+
}) => void) => VoidFunction;
|
|
328
|
+
readonly onReconnectingFailed: (callback: ({ attempts }: {
|
|
329
|
+
attempts: number;
|
|
330
|
+
}) => void) => VoidFunction;
|
|
331
|
+
readonly onEmitterStartEvent: <EmitterType extends EmitterInstance>(callback: ({ emitter }: {
|
|
332
|
+
emitter: EmitterType;
|
|
333
|
+
}) => void) => VoidFunction;
|
|
334
|
+
readonly onEmitterStartEventByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ emitter }: {
|
|
335
|
+
emitter: EmitterType;
|
|
336
|
+
}) => void) => VoidFunction;
|
|
337
|
+
readonly onEmitterError: <EmitterType extends EmitterInstance>(callback: ({ error, emitter }: {
|
|
338
|
+
error: Error;
|
|
339
|
+
emitter: EmitterType;
|
|
340
|
+
}) => void) => VoidFunction;
|
|
341
|
+
readonly onEmitterErrorByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ error, emitter }: {
|
|
342
|
+
error: Error;
|
|
343
|
+
emitter: EmitterType;
|
|
344
|
+
}) => void) => VoidFunction;
|
|
345
|
+
readonly onListenerEvent: <ResponseType = Event>(callback: ({ topic, data, extra, }: {
|
|
346
|
+
topic: string;
|
|
347
|
+
data: ResponseType;
|
|
245
348
|
extra: any;
|
|
246
349
|
}) => void) => VoidFunction;
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
endpoint: string;
|
|
350
|
+
readonly onListenerEventByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic, data, extra, }: {
|
|
351
|
+
topic: string;
|
|
250
352
|
data: ResponseType;
|
|
251
353
|
extra: any;
|
|
252
354
|
}) => void) => VoidFunction;
|
|
253
|
-
onListenerRemove: (callback: (
|
|
254
|
-
|
|
255
|
-
|
|
355
|
+
readonly onListenerRemove: (callback: ({ topic }: {
|
|
356
|
+
topic: string;
|
|
357
|
+
}) => void) => VoidFunction;
|
|
358
|
+
readonly onListenerRemoveByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic }: {
|
|
359
|
+
topic: string;
|
|
360
|
+
}) => void) => VoidFunction;
|
|
256
361
|
};
|
|
257
362
|
url: string;
|
|
258
|
-
|
|
363
|
+
reconnectAttempts: number;
|
|
259
364
|
reconnectTime: number;
|
|
260
|
-
auth?: QueryParamsType | string;
|
|
261
|
-
queryParams?: QueryParamsType | string;
|
|
262
365
|
debug: boolean;
|
|
263
366
|
autoConnect: boolean;
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
adapter:
|
|
367
|
+
unstable_onConnectedCallbacks: OpenCallbackType[];
|
|
368
|
+
unstable_onDisconnectCallbacks: CloseCallbackType[];
|
|
369
|
+
unstable_onReconnectCallbacks: ReconnectCallbackType[];
|
|
370
|
+
unstable_onReconnectFailedCallbacks: ReconnectFailedCallbackType[];
|
|
371
|
+
unstable_onMessageCallbacks: MessageCallbackType<any>[];
|
|
372
|
+
unstable_onSendCallbacks: SendCallbackType<EmitterInstance>[];
|
|
373
|
+
unstable_onErrorCallbacks: ErrorCallbackType<any>[];
|
|
374
|
+
adapter: Adapter;
|
|
272
375
|
loggerManager: LoggerManager;
|
|
273
376
|
appManager: AppManager;
|
|
274
|
-
|
|
275
|
-
|
|
377
|
+
logger: _hyper_fetch_core.LoggerMethods;
|
|
378
|
+
constructor(options: SocketOptionsType<Adapter>);
|
|
276
379
|
/**
|
|
277
|
-
*
|
|
380
|
+
* This method connects the socket to the server
|
|
278
381
|
*/
|
|
279
|
-
|
|
280
|
-
constructor(options: SocketOptionsType<AdapterType>);
|
|
382
|
+
connect: () => Promise<void>;
|
|
281
383
|
/**
|
|
282
|
-
* This method
|
|
384
|
+
* This method disconnects the socket from the server
|
|
283
385
|
*/
|
|
284
|
-
|
|
386
|
+
disconnect: () => Promise<void>;
|
|
285
387
|
/**
|
|
286
|
-
*
|
|
388
|
+
* This method reconnect the socket to the server
|
|
287
389
|
*/
|
|
288
|
-
|
|
390
|
+
reconnect: () => Promise<void>;
|
|
391
|
+
setQueryParams: (queryParams: ExtractAdapterQueryParamsType<Adapter>) => this;
|
|
289
392
|
/**
|
|
290
|
-
*
|
|
393
|
+
* This method enables the logger usage and display the logs in console
|
|
291
394
|
*/
|
|
292
|
-
|
|
395
|
+
setDebug: (enabled: boolean) => this;
|
|
293
396
|
/**
|
|
294
|
-
* Set the
|
|
397
|
+
* Set the logger severity of the messages displayed to the console
|
|
295
398
|
*/
|
|
296
|
-
|
|
399
|
+
setLogLevel: (level: LogLevel) => this;
|
|
297
400
|
/**
|
|
298
|
-
* Set the new
|
|
401
|
+
* Set the new logger instance to the socket
|
|
299
402
|
*/
|
|
300
|
-
|
|
403
|
+
setLogger: (callback: (socket: Socket<Adapter>) => LoggerManager) => this;
|
|
301
404
|
/**
|
|
302
405
|
* Callbacks
|
|
303
406
|
*/
|
|
@@ -306,52 +409,52 @@ declare class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapte
|
|
|
306
409
|
* @param callback
|
|
307
410
|
* @returns
|
|
308
411
|
*/
|
|
309
|
-
|
|
412
|
+
onConnected(callback: OpenCallbackType): this;
|
|
310
413
|
/**
|
|
311
414
|
* Triggered when connection is closed
|
|
312
415
|
* @param callback
|
|
313
416
|
* @returns
|
|
314
417
|
*/
|
|
315
|
-
|
|
418
|
+
onDisconnected(callback: CloseCallbackType): this;
|
|
316
419
|
/**
|
|
317
420
|
* Triggered when connection is getting reconnected
|
|
318
421
|
* @param callback
|
|
319
422
|
* @returns
|
|
320
423
|
*/
|
|
321
|
-
onReconnect(callback: ReconnectCallbackType
|
|
424
|
+
onReconnect(callback: ReconnectCallbackType): this;
|
|
322
425
|
/**
|
|
323
426
|
* Triggered when connection attempts are stopped
|
|
324
427
|
* @param callback
|
|
325
428
|
* @returns
|
|
326
429
|
*/
|
|
327
|
-
|
|
430
|
+
onReconnectFailed(callback: ReconnectFailedCallbackType): this;
|
|
328
431
|
/**
|
|
329
432
|
* Triggered when any message is received
|
|
330
433
|
* @param callback
|
|
331
434
|
* @returns
|
|
332
435
|
*/
|
|
333
|
-
onMessage<Event
|
|
436
|
+
onMessage<Event>(callback: MessageCallbackType<Event>): this;
|
|
334
437
|
/**
|
|
335
438
|
* Triggered when any event is emitted
|
|
336
439
|
* @param callback
|
|
337
440
|
* @returns
|
|
338
441
|
*/
|
|
339
|
-
onSend
|
|
442
|
+
onSend(callback: SendCallbackType<EmitterInstance>): this;
|
|
340
443
|
/**
|
|
341
444
|
* Triggered when we receive error
|
|
342
445
|
* @param callback
|
|
343
446
|
* @returns
|
|
344
447
|
*/
|
|
345
|
-
onError<Event
|
|
448
|
+
onError<Event>(callback: ErrorCallbackType<Event>): this;
|
|
346
449
|
/**
|
|
347
450
|
* ********************
|
|
348
451
|
* Interceptors
|
|
349
452
|
* ********************
|
|
350
453
|
*/
|
|
351
|
-
|
|
352
|
-
|
|
454
|
+
unstable__modifySend: (emitter: EmitterInstance) => EmitterInstance;
|
|
455
|
+
unstable__modifyResponse: (data: {
|
|
353
456
|
data: any;
|
|
354
|
-
extra:
|
|
457
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
355
458
|
}) => {
|
|
356
459
|
data: any;
|
|
357
460
|
extra: any;
|
|
@@ -366,90 +469,214 @@ declare class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapte
|
|
|
366
469
|
* @param options
|
|
367
470
|
* @returns
|
|
368
471
|
*/
|
|
369
|
-
createListener: <
|
|
472
|
+
createListener: <Response>() => <Endpoint extends string>(options: ListenerOptionsType<Endpoint, Adapter>) => Listener<Response, Endpoint, Socket<Adapter>, false>;
|
|
370
473
|
/**
|
|
371
474
|
* Create event emitter
|
|
372
475
|
* @param options
|
|
373
476
|
* @returns
|
|
374
477
|
*/
|
|
375
|
-
createEmitter: <Payload
|
|
478
|
+
createEmitter: <Payload>() => <Endpoint extends string>(options: EmitterOptionsType<Endpoint, Adapter>) => Emitter<Payload, Endpoint, Socket<Adapter>, false, false>;
|
|
376
479
|
}
|
|
377
480
|
|
|
378
481
|
type SocketInstance = Socket<SocketAdapterInstance>;
|
|
379
|
-
type SocketOptionsType<
|
|
482
|
+
type SocketOptionsType<Adapter extends SocketAdapterInstance> = {
|
|
380
483
|
url: string;
|
|
381
|
-
adapter?: AdapterType;
|
|
382
|
-
auth?: QueryParamsType;
|
|
383
484
|
reconnect?: number;
|
|
384
485
|
reconnectTime?: number;
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
queryParamsStringify?: StringifyCallbackType;
|
|
389
|
-
adapterOptions?: ExtractSocketOptionsType<AdapterType>;
|
|
486
|
+
adapter?: (() => Adapter) | Adapter;
|
|
487
|
+
adapterOptions?: ExtractAdapterOptionsType<Adapter>;
|
|
488
|
+
queryParams?: ExtractAdapterQueryParamsType<Adapter>;
|
|
390
489
|
};
|
|
391
|
-
type ReconnectCallbackType
|
|
392
|
-
type
|
|
393
|
-
type OpenCallbackType
|
|
394
|
-
type CloseCallbackType
|
|
395
|
-
type MessageCallbackType<
|
|
396
|
-
|
|
397
|
-
|
|
490
|
+
type ReconnectCallbackType = () => void;
|
|
491
|
+
type ReconnectFailedCallbackType = () => void;
|
|
492
|
+
type OpenCallbackType = () => void;
|
|
493
|
+
type CloseCallbackType = () => void;
|
|
494
|
+
type MessageCallbackType<Event> = (data: {
|
|
495
|
+
event: Event;
|
|
496
|
+
}) => Event;
|
|
497
|
+
type SendCallbackType<EmitterType extends EmitterInstance> = (data: {
|
|
498
|
+
emitter: EmitterType;
|
|
499
|
+
}) => EmitterInstance;
|
|
500
|
+
type ErrorCallbackType<Event> = (data: {
|
|
501
|
+
error: Event;
|
|
502
|
+
}) => void;
|
|
398
503
|
|
|
399
504
|
declare const getErrorKey: () => string;
|
|
400
505
|
declare const getOpenKey: () => string;
|
|
401
506
|
declare const getCloseKey: () => string;
|
|
402
507
|
declare const getConnectingKey: () => string;
|
|
403
508
|
declare const getReconnectingKey: () => string;
|
|
404
|
-
declare const
|
|
509
|
+
declare const getReconnectingFailedKey: () => string;
|
|
405
510
|
declare const getListenerEventKey: () => string;
|
|
406
511
|
declare const getListenerRemoveKey: () => string;
|
|
407
|
-
declare const
|
|
408
|
-
declare const
|
|
409
|
-
declare const
|
|
410
|
-
declare const
|
|
411
|
-
declare const
|
|
512
|
+
declare const getEmitterStartEventKey: () => string;
|
|
513
|
+
declare const getEmitterErrorKey: () => string;
|
|
514
|
+
declare const getListenerRemoveByTopicKey: (event: string) => string;
|
|
515
|
+
declare const getListenerEventByTopicKey: (event: string) => string;
|
|
516
|
+
declare const getEmitterStartEventByTopicKey: (event: string) => string;
|
|
517
|
+
declare const getEmitterErrorByTopicKey: (event: string) => string;
|
|
518
|
+
declare const interceptListener: (interceptors: MessageCallbackType<any>[], event: {
|
|
412
519
|
data: any;
|
|
413
520
|
extra: any;
|
|
414
|
-
}
|
|
521
|
+
}) => {
|
|
415
522
|
data: any;
|
|
416
523
|
extra: any;
|
|
417
524
|
};
|
|
418
525
|
declare const interceptEmitter: <EmitterType extends EmitterInstance>(interceptors: SendCallbackType<EmitterType>[], emitter: EmitterType) => EmitterType;
|
|
419
526
|
|
|
420
|
-
declare const getSocketEvents: <
|
|
421
|
-
emitError: <
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
527
|
+
declare const getSocketEvents: <Adapter extends SocketAdapterInstance>(eventEmitter: EventEmitter) => {
|
|
528
|
+
readonly emitError: <ResponseType>({ error }: {
|
|
529
|
+
error: ResponseType;
|
|
530
|
+
}) => void;
|
|
531
|
+
readonly emitConnected: () => void;
|
|
532
|
+
readonly emitDisconnected: () => void;
|
|
533
|
+
readonly emitConnecting: ({ connecting }: {
|
|
534
|
+
connecting: boolean;
|
|
535
|
+
}) => void;
|
|
536
|
+
readonly emitReconnecting: ({ attempts }: {
|
|
537
|
+
attempts: number;
|
|
538
|
+
}) => void;
|
|
539
|
+
readonly emitReconnectingFailed: ({ attempts }: {
|
|
540
|
+
attempts: number;
|
|
541
|
+
}) => void;
|
|
542
|
+
readonly emitListenerEvent: <ResponseType>({ topic, data, extra, }: {
|
|
543
|
+
topic: string;
|
|
544
|
+
data: ResponseType;
|
|
545
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
546
|
+
}) => void;
|
|
547
|
+
readonly emitListenerRemoveEvent: ({ topic }: {
|
|
548
|
+
topic: string;
|
|
549
|
+
}) => void;
|
|
550
|
+
readonly emitEmitterStartEvent: <EmitterType extends EmitterInstance>({ emitter }: {
|
|
551
|
+
emitter: EmitterType;
|
|
552
|
+
}) => void;
|
|
553
|
+
readonly emitEmitterError: <EmitterType extends EmitterInstance>({ error, emitter, }: {
|
|
554
|
+
error: Error;
|
|
555
|
+
emitter: EmitterType;
|
|
430
556
|
}) => void;
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
onError: (callback: <ResponseType_3>(event: ResponseType_3) => void) => VoidFunction;
|
|
434
|
-
onOpen: (callback: () => void) => VoidFunction;
|
|
435
|
-
onClose: (callback: () => void) => VoidFunction;
|
|
436
|
-
onConnecting: (callback: () => void) => VoidFunction;
|
|
437
|
-
onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
|
|
438
|
-
onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
|
|
439
|
-
onListenerEvent: <ResponseType_4 = Event>(callback: ({ endpoint, data, extra, }: {
|
|
440
|
-
endpoint: string;
|
|
441
|
-
data: ResponseType_4;
|
|
442
|
-
extra: ExtractSocketExtraType<T>;
|
|
557
|
+
readonly onError: (callback: <ResponseType>({ error }: {
|
|
558
|
+
error: ResponseType;
|
|
443
559
|
}) => void) => VoidFunction;
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
560
|
+
readonly onConnected: (callback: () => void) => VoidFunction;
|
|
561
|
+
readonly onDisconnected: (callback: () => void) => VoidFunction;
|
|
562
|
+
readonly onConnecting: (callback: ({ connecting }: {
|
|
563
|
+
connecting: boolean;
|
|
564
|
+
}) => void) => VoidFunction;
|
|
565
|
+
readonly onReconnecting: (callback: ({ attempts }: {
|
|
566
|
+
attempts: number;
|
|
567
|
+
}) => void) => VoidFunction;
|
|
568
|
+
readonly onReconnectingFailed: (callback: ({ attempts }: {
|
|
569
|
+
attempts: number;
|
|
570
|
+
}) => void) => VoidFunction;
|
|
571
|
+
readonly onEmitterStartEvent: <EmitterType extends EmitterInstance>(callback: ({ emitter }: {
|
|
572
|
+
emitter: EmitterType;
|
|
573
|
+
}) => void) => VoidFunction;
|
|
574
|
+
readonly onEmitterStartEventByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ emitter }: {
|
|
575
|
+
emitter: EmitterType;
|
|
576
|
+
}) => void) => VoidFunction;
|
|
577
|
+
readonly onEmitterError: <EmitterType extends EmitterInstance>(callback: ({ error, emitter }: {
|
|
578
|
+
error: Error;
|
|
579
|
+
emitter: EmitterType;
|
|
580
|
+
}) => void) => VoidFunction;
|
|
581
|
+
readonly onEmitterErrorByTopic: <EmitterType extends EmitterInstance>(emitter: Pick<EmitterType, "topic">, callback: ({ error, emitter }: {
|
|
582
|
+
error: Error;
|
|
583
|
+
emitter: EmitterType;
|
|
584
|
+
}) => void) => VoidFunction;
|
|
585
|
+
readonly onListenerEvent: <ResponseType = Event>(callback: ({ topic, data, extra, }: {
|
|
586
|
+
topic: string;
|
|
447
587
|
data: ResponseType;
|
|
448
|
-
extra:
|
|
588
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
589
|
+
}) => void) => VoidFunction;
|
|
590
|
+
readonly onListenerEventByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic, data, extra, }: {
|
|
591
|
+
topic: string;
|
|
592
|
+
data: ResponseType;
|
|
593
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
594
|
+
}) => void) => VoidFunction;
|
|
595
|
+
readonly onListenerRemove: (callback: ({ topic }: {
|
|
596
|
+
topic: string;
|
|
597
|
+
}) => void) => VoidFunction;
|
|
598
|
+
readonly onListenerRemoveByTopic: <ListenerType extends ListenerInstance>(listener: Pick<ListenerType, "topic">, callback: ({ topic }: {
|
|
599
|
+
topic: string;
|
|
449
600
|
}) => 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;
|
|
453
601
|
};
|
|
454
602
|
|
|
455
|
-
|
|
603
|
+
declare const parseMessageEvent: <T extends {
|
|
604
|
+
topic: string;
|
|
605
|
+
data: any;
|
|
606
|
+
event: any;
|
|
607
|
+
}>(event: MessageEvent<any>) => T & {
|
|
608
|
+
event: MessageEvent<any>;
|
|
609
|
+
};
|
|
610
|
+
|
|
611
|
+
declare const getSocketUrl: (url: string, queryParams: string) => string;
|
|
612
|
+
|
|
613
|
+
declare const getSocketError: (event: Event) => string;
|
|
614
|
+
|
|
615
|
+
declare const getWebsocketAdapter: (url: string, adapterOptions: WebsocketAdapterOptionsType | EmptyTypes) => {
|
|
616
|
+
listeners: Map<(...args: any[]) => any, {
|
|
617
|
+
type: keyof WebSocketEventMap;
|
|
618
|
+
listener: (...args: any[]) => void;
|
|
619
|
+
options: any;
|
|
620
|
+
}>;
|
|
621
|
+
addEventListener: <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | (AddEventListenerOptions & {
|
|
622
|
+
disableCleanup?: boolean;
|
|
623
|
+
})) => void;
|
|
624
|
+
removeEventListener: <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions) => void;
|
|
625
|
+
clearListeners: () => void;
|
|
626
|
+
binaryType: BinaryType;
|
|
627
|
+
readonly bufferedAmount: number;
|
|
628
|
+
readonly extensions: string;
|
|
629
|
+
onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
|
|
630
|
+
onerror: ((this: WebSocket, ev: Event) => any) | null;
|
|
631
|
+
onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
|
|
632
|
+
onopen: ((this: WebSocket, ev: Event) => any) | null;
|
|
633
|
+
readonly protocol: string;
|
|
634
|
+
readonly readyState: number;
|
|
635
|
+
readonly url: string;
|
|
636
|
+
close(code?: number, reason?: string): void;
|
|
637
|
+
send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
|
|
638
|
+
readonly CONNECTING: 0;
|
|
639
|
+
readonly OPEN: 1;
|
|
640
|
+
readonly CLOSING: 2;
|
|
641
|
+
readonly CLOSED: 3;
|
|
642
|
+
dispatchEvent(event: Event): boolean;
|
|
643
|
+
} | null;
|
|
644
|
+
|
|
645
|
+
type SSEAdapterOptionsType = {
|
|
646
|
+
eventSourceInit?: EventSourceInit;
|
|
647
|
+
autoConnect?: boolean;
|
|
648
|
+
};
|
|
649
|
+
|
|
650
|
+
/**
|
|
651
|
+
* -------------------------------------------
|
|
652
|
+
* Websocket
|
|
653
|
+
* -------------------------------------------
|
|
654
|
+
*/
|
|
655
|
+
type ServerSentEventsAdapterType = SocketAdapter<MessageEvent<any>, SSEAdapterOptionsType, undefined, undefined, QueryParamsType | string, typeof stringifyQueryParams>;
|
|
656
|
+
declare const ServerSentEventsAdapter: () => ServerSentEventsAdapterType;
|
|
657
|
+
|
|
658
|
+
declare const getServerSentEventsAdapter: (url: string, adapterOptions: SSEAdapterOptionsType | EmptyTypes) => {
|
|
659
|
+
listeners: Map<(...args: any[]) => any, {
|
|
660
|
+
type: keyof EventSourceEventMap;
|
|
661
|
+
listener: (...args: any[]) => void;
|
|
662
|
+
options: any;
|
|
663
|
+
}>;
|
|
664
|
+
onopen: EventSource["onopen"];
|
|
665
|
+
onerror: EventSource["onerror"];
|
|
666
|
+
onmessage: EventSource["onmessage"];
|
|
667
|
+
addEventListener: <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | (AddEventListenerOptions & {
|
|
668
|
+
disableCleanup?: boolean;
|
|
669
|
+
})) => void;
|
|
670
|
+
removeEventListener: <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions) => void;
|
|
671
|
+
clearListeners: () => void;
|
|
672
|
+
readonly readyState: number;
|
|
673
|
+
readonly url: string;
|
|
674
|
+
readonly withCredentials: boolean;
|
|
675
|
+
close(): void;
|
|
676
|
+
readonly CONNECTING: 0;
|
|
677
|
+
readonly OPEN: 1;
|
|
678
|
+
readonly CLOSED: 2;
|
|
679
|
+
dispatchEvent(event: Event): boolean;
|
|
680
|
+
} | null;
|
|
681
|
+
|
|
682
|
+
export { type CloseCallbackType, type ConnectMethodType, type Connector, type EmitMethodOptionsType, type EmitParamsType, type EmitPayloadType, type EmitType, Emitter, type EmitterCallbackErrorType, type EmitterCloneOptionsType, type EmitterInstance, type EmitterInstanceProperties, type EmitterOptionsType, type EmitterRestParams, type ErrorCallbackType, type EventReturnType, type ExtendEmitter, type ExtendListener, type ExtractAdapterEmitterOptionsType, type ExtractAdapterExtraType, type ExtractAdapterListenerOptionsType, type ExtractAdapterOptionsType, type ExtractAdapterQueryParamsMapperType, type ExtractAdapterQueryParamsType, type ExtractEmitterHasParamsType, type ExtractEmitterHasPayloadType, type ExtractEmitterOptionsType, type ExtractEmitterPayloadType, type ExtractEmitterSocketType, type ExtractEmitterTopicType, type ExtractListenerHasParamsType, type ExtractListenerOptionsType, type ExtractListenerResponseType, type ExtractListenerSocketType, type ExtractListenerTopicType, type ExtractSocketAdapterType, type ExtractSocketExtraType, type ExtractSocketOptionsType, type ListenType, Listener, type ListenerCallbackType, type ListenerConfigurationType, type ListenerInstance, type ListenerInstanceProperties, type ListenerOptionsType, type ListenerParamsOptionsType, type MessageCallbackType, type OpenCallbackType, type ReconnectCallbackType, type ReconnectFailedCallbackType, type RemoveListenerCallbackType, type SSEAdapterOptionsType, type SendCallbackType, ServerSentEventsAdapter, type ServerSentEventsAdapterType, Socket, SocketAdapter, type SocketAdapterInstance, type SocketData, type SocketInstance, type SocketOptionsType, type TupleRestType, WebsocketAdapter, type WebsocketAdapterOptionsType, type WebsocketAdapterType, getAdapterBindings, getCloseKey, getConnectingKey, getEmitterErrorByTopicKey, getEmitterErrorKey, getEmitterStartEventByTopicKey, getEmitterStartEventKey, getErrorKey, getListenerEventByTopicKey, getListenerEventKey, getListenerRemoveByTopicKey, getListenerRemoveKey, getOpenKey, getReconnectingFailedKey, getReconnectingKey, getServerSentEventsAdapter, getSocketError, getSocketEvents, getSocketUrl, getWebsocketAdapter, interceptEmitter, interceptListener, parseMessageEvent };
|