@hyper-fetch/sockets 6.0.1 → 7.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- 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
|
@@ -1,70 +1,103 @@
|
|
|
1
|
-
import { ExtractRouteParams,
|
|
1
|
+
import { ExtractRouteParams, EmptyTypes, TypeWithDefaults, ParamsType } from "@hyper-fetch/core";
|
|
2
2
|
|
|
3
|
-
import { SocketAdapterInstance
|
|
3
|
+
import { SocketAdapterInstance } from "adapter";
|
|
4
4
|
import { Emitter } from "emitter";
|
|
5
|
+
import { SocketInstance } from "socket";
|
|
5
6
|
import {
|
|
6
|
-
|
|
7
|
-
|
|
7
|
+
ExtractEmitterSocketType,
|
|
8
|
+
ExtractEmitterHasPayloadType,
|
|
8
9
|
ExtractEmitterHasParamsType,
|
|
9
|
-
|
|
10
|
+
ExtractEmitterTopicType,
|
|
10
11
|
ExtractEmitterPayloadType,
|
|
12
|
+
ExtractAdapterEmitterOptionsType,
|
|
13
|
+
ExtractSocketAdapterType,
|
|
11
14
|
} from "types";
|
|
12
15
|
|
|
13
|
-
export type
|
|
16
|
+
export type EmitterInstanceProperties = {
|
|
17
|
+
payload?: any;
|
|
18
|
+
topic?: string;
|
|
19
|
+
socket?: SocketInstance;
|
|
20
|
+
hasParams?: boolean;
|
|
21
|
+
hasPayload?: boolean;
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
export type EmitterInstance<EmitterProperties extends EmitterInstanceProperties = {}> = Emitter<
|
|
25
|
+
TypeWithDefaults<EmitterProperties, "payload", any>,
|
|
26
|
+
TypeWithDefaults<EmitterProperties, "topic", any>,
|
|
27
|
+
TypeWithDefaults<EmitterProperties, "socket", SocketInstance>,
|
|
28
|
+
TypeWithDefaults<EmitterProperties, "hasPayload", any>,
|
|
29
|
+
TypeWithDefaults<EmitterProperties, "hasParams", any>
|
|
30
|
+
>;
|
|
31
|
+
|
|
32
|
+
export type EmitterCloneOptionsType<Payload, Params, Topic extends string, Socket extends SocketInstance> = {
|
|
33
|
+
payload?: Payload;
|
|
34
|
+
params?: Params | null;
|
|
35
|
+
} & Partial<EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
|
|
14
36
|
|
|
15
|
-
export type EmitterOptionsType<
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
options?: ExtractEmitterOptionsType<AdapterType>;
|
|
37
|
+
export type EmitterOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
|
|
38
|
+
topic: Topic;
|
|
39
|
+
options?: ExtractAdapterEmitterOptionsType<AdapterType>;
|
|
19
40
|
};
|
|
20
41
|
|
|
21
|
-
export type
|
|
22
|
-
response:
|
|
23
|
-
| { error: Error; data: null; extra: null }
|
|
24
|
-
| { error: null; data: Response; extra: ExtractSocketExtraType<AdapterType> },
|
|
25
|
-
) => void;
|
|
42
|
+
export type EmitterCallbackErrorType = (data: { error: Error }) => void;
|
|
26
43
|
|
|
27
44
|
// Emit
|
|
28
45
|
|
|
29
|
-
export type
|
|
46
|
+
export type EmitPayloadType<Payload, HasPayload extends boolean> = HasPayload extends false
|
|
30
47
|
? {
|
|
31
|
-
|
|
48
|
+
payload: Payload;
|
|
32
49
|
}
|
|
33
|
-
: {
|
|
50
|
+
: { payload?: Payload };
|
|
34
51
|
|
|
35
|
-
export type EmitParamsType<
|
|
36
|
-
|
|
37
|
-
|
|
52
|
+
export type EmitParamsType<
|
|
53
|
+
Params extends ParamsType | EmptyTypes,
|
|
54
|
+
HasPayload extends boolean,
|
|
55
|
+
> = HasPayload extends false
|
|
56
|
+
? Params extends EmptyTypes
|
|
57
|
+
? { params?: Params }
|
|
38
58
|
: {
|
|
39
59
|
params: Params;
|
|
40
60
|
}
|
|
41
|
-
: { params?:
|
|
61
|
+
: { params?: Params };
|
|
42
62
|
|
|
43
|
-
export type
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
63
|
+
export type EmitterRestParams<Adapter extends SocketAdapterInstance> =
|
|
64
|
+
ExtractAdapterEmitterOptionsType<Adapter> extends any
|
|
65
|
+
? {}
|
|
66
|
+
: ExtractAdapterEmitterOptionsType<Adapter> extends Record<string, any>
|
|
67
|
+
? { options?: ExtractAdapterEmitterOptionsType<Adapter> }
|
|
68
|
+
: {};
|
|
69
|
+
|
|
70
|
+
export type EmitMethodOptionsType<Emitter extends EmitterInstance> = EmitPayloadType<
|
|
71
|
+
ExtractEmitterPayloadType<Emitter>,
|
|
72
|
+
ExtractEmitterHasPayloadType<Emitter>
|
|
73
|
+
> &
|
|
74
|
+
EmitParamsType<ExtractRouteParams<ExtractEmitterTopicType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> &
|
|
75
|
+
EmitterRestParams<ExtractSocketAdapterType<ExtractEmitterSocketType<Emitter>>>;
|
|
76
|
+
|
|
77
|
+
export type EmitType<Emitter extends EmitterInstance> =
|
|
78
|
+
ExtractEmitterHasPayloadType<Emitter> extends false
|
|
79
|
+
? (options: EmitMethodOptionsType<Emitter>) => void
|
|
80
|
+
: ExtractRouteParams<ExtractEmitterTopicType<Emitter>> extends EmptyTypes
|
|
81
|
+
? (options?: EmitMethodOptionsType<Emitter>) => void
|
|
82
|
+
: ExtractEmitterHasParamsType<Emitter> extends false
|
|
83
|
+
? (options: EmitMethodOptionsType<Emitter>) => void
|
|
84
|
+
: (options?: EmitMethodOptionsType<Emitter>) => void;
|
|
47
85
|
|
|
48
|
-
export type
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
?
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
: (
|
|
67
|
-
options?: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> &
|
|
68
|
-
EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> &
|
|
69
|
-
EmitRestType<Emitter>,
|
|
70
|
-
) => string;
|
|
86
|
+
export type ExtendEmitter<
|
|
87
|
+
T extends EmitterInstance,
|
|
88
|
+
Properties extends {
|
|
89
|
+
payload?: any;
|
|
90
|
+
response?: any;
|
|
91
|
+
topic?: string;
|
|
92
|
+
socket?: SocketInstance;
|
|
93
|
+
mappedData?: any;
|
|
94
|
+
hasData?: true | false;
|
|
95
|
+
hasParams?: true | false;
|
|
96
|
+
},
|
|
97
|
+
> = Emitter<
|
|
98
|
+
TypeWithDefaults<Properties, "payload", ExtractEmitterPayloadType<T>>,
|
|
99
|
+
Properties["topic"] extends string ? Properties["topic"] : ExtractEmitterTopicType<T>,
|
|
100
|
+
Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractEmitterSocketType<T>,
|
|
101
|
+
Properties["hasData"] extends true ? true : ExtractEmitterHasPayloadType<T>,
|
|
102
|
+
Properties["hasParams"] extends true ? true : ExtractEmitterHasParamsType<T>
|
|
103
|
+
>;
|
package/src/index.ts
CHANGED
package/src/listener/listener.ts
CHANGED
|
@@ -1,83 +1,68 @@
|
|
|
1
1
|
import { ExtractRouteParams, ParamsType } from "@hyper-fetch/core";
|
|
2
2
|
|
|
3
|
-
import {
|
|
4
|
-
import { ListenType, ListenerOptionsType } from "listener";
|
|
5
|
-
import {
|
|
6
|
-
import { ConnectMethodType } from "types";
|
|
3
|
+
import { SocketInstance } from "socket";
|
|
4
|
+
import { ListenType, ListenerConfigurationType, ListenerOptionsType } from "listener";
|
|
5
|
+
import { ExtractAdapterListenerOptionsType, ExtractSocketAdapterType } from "types";
|
|
7
6
|
|
|
8
7
|
export class Listener<
|
|
9
8
|
Response,
|
|
10
|
-
|
|
11
|
-
|
|
9
|
+
Topic extends string,
|
|
10
|
+
Socket extends SocketInstance,
|
|
12
11
|
HasParams extends boolean = false,
|
|
13
12
|
> {
|
|
14
|
-
readonly
|
|
13
|
+
readonly topic: Topic;
|
|
15
14
|
params?: ParamsType;
|
|
16
|
-
options?:
|
|
17
|
-
connections: Set<ConnectMethodType<AdapterType, Response>> = new Set();
|
|
15
|
+
options?: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>;
|
|
18
16
|
|
|
19
17
|
constructor(
|
|
20
|
-
readonly socket: Socket
|
|
21
|
-
readonly listenerOptions
|
|
18
|
+
readonly socket: Socket,
|
|
19
|
+
readonly listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>,
|
|
22
20
|
) {
|
|
23
|
-
const {
|
|
24
|
-
this.
|
|
21
|
+
const { topic, options } = listenerOptions;
|
|
22
|
+
this.topic = topic;
|
|
25
23
|
this.options = options;
|
|
26
24
|
}
|
|
27
25
|
|
|
28
|
-
setOptions(options:
|
|
26
|
+
setOptions(options: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>) {
|
|
29
27
|
return this.clone({ options });
|
|
30
28
|
}
|
|
31
29
|
|
|
32
|
-
setParams(params: ExtractRouteParams<
|
|
30
|
+
setParams(params: ExtractRouteParams<Topic>) {
|
|
33
31
|
return this.clone<true>({ params });
|
|
34
32
|
}
|
|
35
33
|
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
endpoint = endpoint.replace(new RegExp(`:${key}`, "g"), String(value));
|
|
41
|
-
});
|
|
42
|
-
}
|
|
43
|
-
|
|
44
|
-
return endpoint as Endpoint;
|
|
45
|
-
};
|
|
46
|
-
|
|
47
|
-
/**
|
|
48
|
-
* Attach global logic to the received events
|
|
49
|
-
* @param callback
|
|
50
|
-
*/
|
|
51
|
-
onData(callback: ConnectMethodType<AdapterType, Response>) {
|
|
52
|
-
this.connections.add(callback);
|
|
53
|
-
return this;
|
|
54
|
-
}
|
|
55
|
-
|
|
56
|
-
clone<Params extends boolean = HasParams>(options?: Partial<ListenerOptionsType<Endpoint, AdapterType>>) {
|
|
57
|
-
const newInstance = new Listener<Response, Endpoint, AdapterType, Params>(this.socket, {
|
|
34
|
+
clone<NewHasParams extends true | false = HasParams>(
|
|
35
|
+
options?: ListenerConfigurationType<ExtractRouteParams<Topic>, Topic, Socket>,
|
|
36
|
+
) {
|
|
37
|
+
const newInstance = new Listener<Response, Topic, Socket, NewHasParams>(this.socket, {
|
|
58
38
|
...this.listenerOptions,
|
|
59
39
|
...options,
|
|
60
|
-
|
|
40
|
+
topic: this.paramsMapper(options?.params || this.params),
|
|
61
41
|
});
|
|
62
42
|
|
|
63
|
-
newInstance.connections = this.connections;
|
|
64
43
|
return newInstance;
|
|
65
44
|
}
|
|
66
45
|
|
|
67
|
-
listen: ListenType<
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
|
|
72
|
-
return callback(response as any);
|
|
73
|
-
};
|
|
74
|
-
|
|
75
|
-
this.socket.adapter.listen(instance, action);
|
|
46
|
+
listen: ListenType<Listener<Response, Topic, Socket, HasParams>, Socket> = (
|
|
47
|
+
callback: Parameters<ListenType<Listener<Response, Topic, Socket, HasParams>, Socket>>[0],
|
|
48
|
+
) => {
|
|
49
|
+
this.socket.adapter.listen(this, callback);
|
|
76
50
|
|
|
77
51
|
const removeListener = () => {
|
|
78
|
-
this.socket.adapter.removeListener(
|
|
52
|
+
this.socket.adapter.removeListener({ topic: this.topic, callback });
|
|
79
53
|
};
|
|
80
54
|
|
|
81
55
|
return removeListener;
|
|
82
56
|
};
|
|
57
|
+
|
|
58
|
+
private paramsMapper = (params: ParamsType | null | undefined): Topic => {
|
|
59
|
+
let topic = this.listenerOptions.topic as string;
|
|
60
|
+
if (params) {
|
|
61
|
+
Object.entries(params).forEach(([key, value]) => {
|
|
62
|
+
topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
|
|
63
|
+
});
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
return topic as Topic;
|
|
67
|
+
};
|
|
83
68
|
}
|
|
@@ -1,27 +1,79 @@
|
|
|
1
|
-
import { ExtractRouteParams,
|
|
1
|
+
import { ExtractRouteParams, EmptyTypes, TypeWithDefaults } from "@hyper-fetch/core";
|
|
2
2
|
|
|
3
|
-
import { SocketAdapterInstance
|
|
3
|
+
import { SocketAdapterInstance } from "adapter";
|
|
4
4
|
import { Listener } from "listener";
|
|
5
|
-
import {
|
|
5
|
+
import { SocketInstance } from "socket";
|
|
6
|
+
import {
|
|
7
|
+
ExtractListenerHasParamsType,
|
|
8
|
+
ExtractListenerTopicType,
|
|
9
|
+
ExtractListenerResponseType,
|
|
10
|
+
ExtractAdapterListenerOptionsType,
|
|
11
|
+
ExtractAdapterExtraType,
|
|
12
|
+
ExtractListenerSocketType,
|
|
13
|
+
ExtractSocketAdapterType,
|
|
14
|
+
} from "types";
|
|
6
15
|
|
|
7
|
-
export type
|
|
16
|
+
export type ListenerInstanceProperties = {
|
|
17
|
+
response?: any;
|
|
18
|
+
topic?: string;
|
|
19
|
+
socket?: SocketInstance;
|
|
20
|
+
hasParams?: boolean;
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
export type ListenerInstance<ListenerProperties extends ListenerInstanceProperties = {}> = Listener<
|
|
24
|
+
TypeWithDefaults<ListenerProperties, "response", any>,
|
|
25
|
+
TypeWithDefaults<ListenerProperties, "topic", any>,
|
|
26
|
+
TypeWithDefaults<ListenerProperties, "socket", SocketInstance>,
|
|
27
|
+
TypeWithDefaults<ListenerProperties, "hasParams", any>
|
|
28
|
+
>;
|
|
8
29
|
|
|
9
|
-
export type ListenerOptionsType<
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
options?: ExtractListenerOptionsType<AdapterType>;
|
|
30
|
+
export type ListenerOptionsType<Topic extends string, AdapterType extends SocketAdapterInstance> = {
|
|
31
|
+
topic: Topic;
|
|
32
|
+
options?: ExtractAdapterListenerOptionsType<AdapterType>;
|
|
13
33
|
};
|
|
14
34
|
|
|
15
|
-
export type
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
35
|
+
export type ListenerConfigurationType<Params, Topic extends string, Socket extends SocketInstance> = {
|
|
36
|
+
params?: Params;
|
|
37
|
+
} & Partial<ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>>;
|
|
38
|
+
|
|
39
|
+
export type ListenerParamsOptionsType<Listener extends ListenerInstance> =
|
|
40
|
+
ExtractListenerHasParamsType<Listener> extends false
|
|
19
41
|
? {
|
|
20
|
-
params: ExtractRouteParams<
|
|
21
|
-
callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
|
|
42
|
+
params: ExtractRouteParams<ExtractListenerTopicType<Listener>>;
|
|
22
43
|
}
|
|
23
44
|
: {
|
|
24
45
|
params?: never;
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
export type ListenType<Listener extends ListenerInstance, Socket extends SocketInstance> =
|
|
49
|
+
ExtractRouteParams<ExtractListenerTopicType<Listener>> extends EmptyTypes
|
|
50
|
+
? (
|
|
51
|
+
callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>,
|
|
52
|
+
) => () => void
|
|
53
|
+
: ExtractListenerHasParamsType<Listener> extends true
|
|
54
|
+
? (
|
|
55
|
+
callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>,
|
|
56
|
+
) => () => void
|
|
57
|
+
: (
|
|
58
|
+
callback: ListenerCallbackType<ExtractSocketAdapterType<Socket>, ExtractListenerResponseType<Listener>>,
|
|
59
|
+
) => () => void;
|
|
60
|
+
|
|
61
|
+
export type ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
|
|
62
|
+
data: D;
|
|
63
|
+
extra: ExtractAdapterExtraType<AdapterType>;
|
|
64
|
+
}) => void;
|
|
65
|
+
|
|
66
|
+
export type ExtendListener<
|
|
67
|
+
T extends ListenerInstance,
|
|
68
|
+
Properties extends {
|
|
69
|
+
response?: any;
|
|
70
|
+
topic?: string;
|
|
71
|
+
socket?: SocketInstance;
|
|
72
|
+
hasParams?: true | false;
|
|
73
|
+
},
|
|
74
|
+
> = Listener<
|
|
75
|
+
TypeWithDefaults<Properties, "response", ExtractListenerResponseType<T>>,
|
|
76
|
+
Properties["topic"] extends string ? Properties["topic"] : ExtractListenerTopicType<T>,
|
|
77
|
+
Properties["socket"] extends SocketInstance ? Properties["socket"] : ExtractListenerSocketType<T>,
|
|
78
|
+
Properties["hasParams"] extends true ? true : ExtractListenerHasParamsType<T>
|
|
79
|
+
>;
|
|
@@ -4,128 +4,163 @@ import {
|
|
|
4
4
|
getErrorKey,
|
|
5
5
|
getCloseKey,
|
|
6
6
|
getConnectingKey,
|
|
7
|
-
getEmitterEventKey,
|
|
8
7
|
getListenerEventKey,
|
|
9
8
|
getOpenKey,
|
|
10
9
|
getReconnectingKey,
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
getEmitterEventByEndpointKey,
|
|
10
|
+
getReconnectingFailedKey,
|
|
11
|
+
getListenerEventByTopicKey,
|
|
14
12
|
getListenerRemoveKey,
|
|
15
|
-
|
|
13
|
+
getListenerRemoveByTopicKey,
|
|
14
|
+
getEmitterStartEventKey,
|
|
15
|
+
getEmitterStartEventByTopicKey,
|
|
16
|
+
getEmitterErrorKey,
|
|
17
|
+
getEmitterErrorByTopicKey,
|
|
16
18
|
} from "socket";
|
|
17
19
|
import { EmitterInstance } from "emitter";
|
|
18
20
|
import { ListenerInstance } from "listener";
|
|
19
|
-
import {
|
|
21
|
+
import { SocketAdapterInstance } from "adapter";
|
|
22
|
+
import { ExtractAdapterExtraType } from "types";
|
|
20
23
|
|
|
21
|
-
export const getSocketEvents = <
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
): void => {
|
|
44
|
-
eventEmitter.emit(getListenerEventKey(), { endpoint, data, extra });
|
|
45
|
-
eventEmitter.emit(getListenerEventByEndpointKey(endpoint), { endpoint, data, extra });
|
|
46
|
-
},
|
|
47
|
-
emitListenerRemoveEvent: (endpoint: string): void => {
|
|
48
|
-
eventEmitter.emit(getListenerRemoveKey(), endpoint);
|
|
49
|
-
eventEmitter.emit(getListenerRemoveByEndpointKey(endpoint));
|
|
50
|
-
},
|
|
51
|
-
emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType): void => {
|
|
52
|
-
eventEmitter.emit(getEmitterEventKey(), emitter);
|
|
53
|
-
eventEmitter.emit(getEmitterEventByEndpointKey(emitter.endpoint), emitter);
|
|
54
|
-
},
|
|
55
|
-
|
|
56
|
-
onError: (callback: <ResponseType>(event: ResponseType) => void): VoidFunction => {
|
|
57
|
-
eventEmitter.on(getErrorKey(), callback);
|
|
58
|
-
return () => eventEmitter.removeListener(getErrorKey(), callback);
|
|
59
|
-
},
|
|
60
|
-
onOpen: (callback: () => void): VoidFunction => {
|
|
61
|
-
eventEmitter.on(getOpenKey(), callback);
|
|
62
|
-
return () => eventEmitter.removeListener(getOpenKey(), callback);
|
|
63
|
-
},
|
|
64
|
-
onClose: (callback: () => void): VoidFunction => {
|
|
65
|
-
eventEmitter.on(getCloseKey(), callback);
|
|
66
|
-
return () => eventEmitter.removeListener(getCloseKey(), callback);
|
|
67
|
-
},
|
|
68
|
-
onConnecting: (callback: () => void): VoidFunction => {
|
|
69
|
-
eventEmitter.on(getConnectingKey(), callback);
|
|
70
|
-
return () => eventEmitter.removeListener(getConnectingKey(), callback);
|
|
71
|
-
},
|
|
72
|
-
onReconnecting: (callback: (attempts: number) => void): VoidFunction => {
|
|
73
|
-
eventEmitter.on(getReconnectingKey(), callback);
|
|
74
|
-
return () => eventEmitter.removeListener(getReconnectingKey(), callback);
|
|
75
|
-
},
|
|
76
|
-
onReconnectingStop: (callback: (attempts: number) => void): VoidFunction => {
|
|
77
|
-
eventEmitter.on(getReconnectingStopKey(), callback);
|
|
78
|
-
return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
|
|
79
|
-
},
|
|
80
|
-
onListenerEvent: <ResponseType = Event>(
|
|
81
|
-
callback: ({
|
|
82
|
-
endpoint,
|
|
24
|
+
export const getSocketEvents = <Adapter extends SocketAdapterInstance>(eventEmitter: EventEmitter) =>
|
|
25
|
+
({
|
|
26
|
+
emitError: <ResponseType>({ error }: { error: ResponseType }): void => {
|
|
27
|
+
eventEmitter.emit(getErrorKey(), { error });
|
|
28
|
+
},
|
|
29
|
+
emitConnected: (): void => {
|
|
30
|
+
eventEmitter.emit(getOpenKey());
|
|
31
|
+
},
|
|
32
|
+
emitDisconnected: (): void => {
|
|
33
|
+
eventEmitter.emit(getCloseKey());
|
|
34
|
+
},
|
|
35
|
+
emitConnecting: ({ connecting }: { connecting: boolean }): void => {
|
|
36
|
+
eventEmitter.emit(getConnectingKey(), { connecting });
|
|
37
|
+
},
|
|
38
|
+
emitReconnecting: ({ attempts }: { attempts: number }): void => {
|
|
39
|
+
eventEmitter.emit(getReconnectingKey(), { attempts });
|
|
40
|
+
},
|
|
41
|
+
emitReconnectingFailed: ({ attempts }: { attempts: number }): void => {
|
|
42
|
+
eventEmitter.emit(getReconnectingFailedKey(), { attempts });
|
|
43
|
+
},
|
|
44
|
+
emitListenerEvent: <ResponseType>({
|
|
45
|
+
topic,
|
|
83
46
|
data,
|
|
84
47
|
extra,
|
|
85
48
|
}: {
|
|
86
|
-
|
|
49
|
+
topic: string;
|
|
87
50
|
data: ResponseType;
|
|
88
|
-
extra:
|
|
89
|
-
}) =>
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
51
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
52
|
+
}): void => {
|
|
53
|
+
eventEmitter.emit(getListenerEventKey(), { topic, data, extra });
|
|
54
|
+
eventEmitter.emit(getListenerEventByTopicKey(topic), { topic, data, extra });
|
|
55
|
+
},
|
|
56
|
+
emitListenerRemoveEvent: ({ topic }: { topic: string }): void => {
|
|
57
|
+
eventEmitter.emit(getListenerRemoveKey(), { topic });
|
|
58
|
+
eventEmitter.emit(getListenerRemoveByTopicKey(topic), { topic });
|
|
59
|
+
},
|
|
60
|
+
emitEmitterStartEvent: <EmitterType extends EmitterInstance>({ emitter }: { emitter: EmitterType }): void => {
|
|
61
|
+
eventEmitter.emit(getEmitterStartEventKey(), { emitter });
|
|
62
|
+
eventEmitter.emit(getEmitterStartEventByTopicKey(emitter.topic), { emitter });
|
|
63
|
+
},
|
|
64
|
+
emitEmitterError: <EmitterType extends EmitterInstance>({
|
|
65
|
+
error,
|
|
66
|
+
emitter,
|
|
104
67
|
}: {
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
callback: () => void
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
})
|
|
68
|
+
error: Error;
|
|
69
|
+
emitter: EmitterType;
|
|
70
|
+
}): void => {
|
|
71
|
+
eventEmitter.emit(getEmitterErrorKey(), { error, emitter });
|
|
72
|
+
eventEmitter.emit(getEmitterErrorByTopicKey(emitter.topic), { error, emitter });
|
|
73
|
+
},
|
|
74
|
+
onError: (callback: <ResponseType>({ error }: { error: ResponseType }) => void): VoidFunction => {
|
|
75
|
+
eventEmitter.on(getErrorKey(), callback);
|
|
76
|
+
return () => eventEmitter.removeListener(getErrorKey(), callback);
|
|
77
|
+
},
|
|
78
|
+
onConnected: (callback: () => void): VoidFunction => {
|
|
79
|
+
eventEmitter.on(getOpenKey(), callback);
|
|
80
|
+
return () => eventEmitter.removeListener(getOpenKey(), callback);
|
|
81
|
+
},
|
|
82
|
+
onDisconnected: (callback: () => void): VoidFunction => {
|
|
83
|
+
eventEmitter.on(getCloseKey(), callback);
|
|
84
|
+
return () => eventEmitter.removeListener(getCloseKey(), callback);
|
|
85
|
+
},
|
|
86
|
+
onConnecting: (callback: ({ connecting }: { connecting: boolean }) => void): VoidFunction => {
|
|
87
|
+
eventEmitter.on(getConnectingKey(), callback);
|
|
88
|
+
return () => eventEmitter.removeListener(getConnectingKey(), callback);
|
|
89
|
+
},
|
|
90
|
+
onReconnecting: (callback: ({ attempts }: { attempts: number }) => void): VoidFunction => {
|
|
91
|
+
eventEmitter.on(getReconnectingKey(), callback);
|
|
92
|
+
return () => eventEmitter.removeListener(getReconnectingKey(), callback);
|
|
93
|
+
},
|
|
94
|
+
onReconnectingFailed: (callback: ({ attempts }: { attempts: number }) => void): VoidFunction => {
|
|
95
|
+
eventEmitter.on(getReconnectingFailedKey(), callback);
|
|
96
|
+
return () => eventEmitter.removeListener(getReconnectingFailedKey(), callback);
|
|
97
|
+
},
|
|
98
|
+
// Emitters
|
|
99
|
+
onEmitterStartEvent: <EmitterType extends EmitterInstance>(
|
|
100
|
+
callback: ({ emitter }: { emitter: EmitterType }) => void,
|
|
101
|
+
): VoidFunction => {
|
|
102
|
+
eventEmitter.on(getEmitterStartEventKey(), callback);
|
|
103
|
+
return () => eventEmitter.removeListener(getEmitterStartEventKey(), callback);
|
|
104
|
+
},
|
|
105
|
+
onEmitterStartEventByTopic: <EmitterType extends EmitterInstance>(
|
|
106
|
+
emitter: Pick<EmitterType, "topic">,
|
|
107
|
+
callback: ({ emitter }: { emitter: EmitterType }) => void,
|
|
108
|
+
): VoidFunction => {
|
|
109
|
+
eventEmitter.on(getEmitterStartEventByTopicKey(emitter.topic), callback);
|
|
110
|
+
return () => eventEmitter.removeListener(getEmitterStartEventByTopicKey(emitter.topic), callback);
|
|
111
|
+
},
|
|
112
|
+
onEmitterError: <EmitterType extends EmitterInstance>(
|
|
113
|
+
callback: ({ error, emitter }: { error: Error; emitter: EmitterType }) => void,
|
|
114
|
+
): VoidFunction => {
|
|
115
|
+
eventEmitter.on(getEmitterErrorKey(), callback);
|
|
116
|
+
return () => eventEmitter.removeListener(getEmitterErrorKey(), callback);
|
|
117
|
+
},
|
|
118
|
+
onEmitterErrorByTopic: <EmitterType extends EmitterInstance>(
|
|
119
|
+
emitter: Pick<EmitterType, "topic">,
|
|
120
|
+
callback: ({ error, emitter }: { error: Error; emitter: EmitterType }) => void,
|
|
121
|
+
): VoidFunction => {
|
|
122
|
+
eventEmitter.on(getEmitterErrorByTopicKey(emitter.topic), callback);
|
|
123
|
+
return () => eventEmitter.removeListener(getEmitterErrorByTopicKey(emitter.topic), callback);
|
|
124
|
+
},
|
|
125
|
+
// Listeners
|
|
126
|
+
onListenerEvent: <ResponseType = Event>(
|
|
127
|
+
callback: ({
|
|
128
|
+
topic,
|
|
129
|
+
data,
|
|
130
|
+
extra,
|
|
131
|
+
}: {
|
|
132
|
+
topic: string;
|
|
133
|
+
data: ResponseType;
|
|
134
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
135
|
+
}) => void,
|
|
136
|
+
): VoidFunction => {
|
|
137
|
+
eventEmitter.on(getListenerEventKey(), callback);
|
|
138
|
+
return () => eventEmitter.removeListener(getListenerEventKey(), callback);
|
|
139
|
+
},
|
|
140
|
+
onListenerEventByTopic: <ListenerType extends ListenerInstance>(
|
|
141
|
+
listener: Pick<ListenerType, "topic">,
|
|
142
|
+
callback: ({
|
|
143
|
+
topic,
|
|
144
|
+
data,
|
|
145
|
+
extra,
|
|
146
|
+
}: {
|
|
147
|
+
topic: string;
|
|
148
|
+
data: ResponseType;
|
|
149
|
+
extra: ExtractAdapterExtraType<Adapter>;
|
|
150
|
+
}) => void,
|
|
151
|
+
): VoidFunction => {
|
|
152
|
+
eventEmitter.on(getListenerEventByTopicKey(listener.topic), callback);
|
|
153
|
+
return () => eventEmitter.removeListener(getListenerEventByTopicKey(listener.topic), callback);
|
|
154
|
+
},
|
|
155
|
+
onListenerRemove: (callback: ({ topic }: { topic: string }) => void): VoidFunction => {
|
|
156
|
+
eventEmitter.on(getListenerRemoveKey(), callback);
|
|
157
|
+
return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
|
|
158
|
+
},
|
|
159
|
+
onListenerRemoveByTopic: <ListenerType extends ListenerInstance>(
|
|
160
|
+
listener: Pick<ListenerType, "topic">,
|
|
161
|
+
callback: ({ topic }: { topic: string }) => void,
|
|
162
|
+
): VoidFunction => {
|
|
163
|
+
eventEmitter.on(getListenerRemoveByTopicKey(listener.topic), callback);
|
|
164
|
+
return () => eventEmitter.removeListener(getListenerRemoveByTopicKey(listener.topic), callback);
|
|
165
|
+
},
|
|
166
|
+
}) as const;
|