@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.
Files changed (41) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +6 -6
  3. package/dist/index.d.ts +523 -296
  4. package/dist/index.js +1246 -0
  5. package/dist/index.js.map +7 -0
  6. package/package.json +8 -9
  7. package/src/adapter/adapter.bindings.ts +128 -101
  8. package/src/adapter/adapter.ts +231 -0
  9. package/src/adapter/adapter.types.ts +10 -101
  10. package/src/adapter/index.ts +4 -4
  11. package/src/adapter-sse/index.ts +3 -0
  12. package/src/adapter-sse/sse-adapter.ts +192 -0
  13. package/src/adapter-sse/sse-adapter.types.ts +6 -0
  14. package/src/adapter-sse/sse-adapter.utils.ts +77 -0
  15. package/src/adapter-websockets/index.ts +3 -0
  16. package/src/adapter-websockets/websocket-adapter.ts +259 -0
  17. package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
  18. package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
  19. package/src/emitter/emitter.ts +60 -102
  20. package/src/emitter/emitter.types.ts +82 -49
  21. package/src/index.ts +3 -0
  22. package/src/listener/listener.ts +34 -49
  23. package/src/listener/listener.types.ts +69 -17
  24. package/src/socket/socket.events.ts +147 -112
  25. package/src/socket/socket.ts +78 -100
  26. package/src/socket/socket.types.ts +13 -18
  27. package/src/socket/socket.utils.ts +12 -14
  28. package/src/types/connect.types.ts +2 -2
  29. package/src/types/extract.types.ts +43 -10
  30. package/src/utils/index.ts +3 -0
  31. package/src/utils/message-event.utils.ts +6 -0
  32. package/src/utils/socket.errors.ts +48 -0
  33. package/src/utils/socket.utils.ts +4 -0
  34. package/tsconfig.json +7 -3
  35. package/dist/index.cjs.js +0 -853
  36. package/dist/index.cjs.js.map +0 -7
  37. package/dist/index.esm.js +0 -833
  38. package/dist/index.esm.js.map +0 -7
  39. package/src/adapter/adapter.sse.ts +0 -127
  40. package/src/adapter/adapter.utils.ts +0 -20
  41. package/src/adapter/adapter.websocket.ts +0 -187
@@ -1,70 +1,103 @@
1
- import { ExtractRouteParams, NegativeTypes } from "@hyper-fetch/core";
1
+ import { ExtractRouteParams, EmptyTypes, TypeWithDefaults, ParamsType } from "@hyper-fetch/core";
2
2
 
3
- import { SocketAdapterInstance, ExtractEmitterOptionsType, ExtractSocketExtraType } from "adapter";
3
+ import { SocketAdapterInstance } from "adapter";
4
4
  import { Emitter } from "emitter";
5
+ import { SocketInstance } from "socket";
5
6
  import {
6
- ExtractEmitterAdapterType,
7
- ExtractEmitterHasDataType,
7
+ ExtractEmitterSocketType,
8
+ ExtractEmitterHasPayloadType,
8
9
  ExtractEmitterHasParamsType,
9
- ExtractEmitterEndpointType,
10
+ ExtractEmitterTopicType,
10
11
  ExtractEmitterPayloadType,
12
+ ExtractAdapterEmitterOptionsType,
13
+ ExtractSocketAdapterType,
11
14
  } from "types";
12
15
 
13
- export type EmitterInstance = Emitter<any, any, any, SocketAdapterInstance, any, any, any>;
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<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
16
- endpoint: Endpoint;
17
- timeout?: number;
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 EmitterAcknowledgeType<Response, AdapterType extends SocketAdapterInstance> = (
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 EmitDataType<Payload, HasData extends boolean> = HasData extends false
46
+ export type EmitPayloadType<Payload, HasPayload extends boolean> = HasPayload extends false
30
47
  ? {
31
- data: Payload;
48
+ payload: Payload;
32
49
  }
33
- : { data?: never };
50
+ : { payload?: Payload };
34
51
 
35
- export type EmitParamsType<Params, HasData extends boolean> = HasData extends false
36
- ? Params extends NegativeTypes
37
- ? { params?: never }
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?: never };
61
+ : { params?: Params };
42
62
 
43
- export type EmitRestType<Emitter extends EmitterInstance> = {
44
- options?: Partial<EmitterOptionsType<ExtractEmitterEndpointType<Emitter>, ExtractEmitterAdapterType<Emitter>>>;
45
- ack?: EmitterAcknowledgeType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterAdapterType<Emitter>>;
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 EmitType<Emitter extends EmitterInstance> = ExtractEmitterHasDataType<Emitter> extends false
49
- ? (
50
- options: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> &
51
- EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> &
52
- EmitRestType<Emitter>,
53
- ) => string
54
- : ExtractRouteParams<ExtractEmitterEndpointType<Emitter>> extends NegativeTypes
55
- ? (
56
- options?: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> &
57
- EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> &
58
- EmitRestType<Emitter>,
59
- ) => string
60
- : ExtractEmitterHasParamsType<Emitter> extends false
61
- ? (
62
- options: EmitDataType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterHasParamsType<Emitter>> &
63
- EmitParamsType<ExtractRouteParams<ExtractEmitterEndpointType<Emitter>>, ExtractEmitterHasParamsType<Emitter>> &
64
- EmitRestType<Emitter>,
65
- ) => string
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
@@ -3,3 +3,6 @@ export * from "./adapter";
3
3
  export * from "./emitter";
4
4
  export * from "./listener";
5
5
  export * from "./types";
6
+ export * from "./utils";
7
+ export * from "./adapter-websockets";
8
+ export * from "./adapter-sse";
@@ -1,83 +1,68 @@
1
1
  import { ExtractRouteParams, ParamsType } from "@hyper-fetch/core";
2
2
 
3
- import { Socket } from "socket";
4
- import { ListenType, ListenerOptionsType } from "listener";
5
- import { ExtractSocketExtraType, SocketAdapterType, ExtractListenerOptionsType } from "adapter";
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
- Endpoint extends string,
11
- AdapterType extends SocketAdapterType,
9
+ Topic extends string,
10
+ Socket extends SocketInstance,
12
11
  HasParams extends boolean = false,
13
12
  > {
14
- readonly endpoint: Endpoint;
13
+ readonly topic: Topic;
15
14
  params?: ParamsType;
16
- options?: ExtractListenerOptionsType<AdapterType>;
17
- connections: Set<ConnectMethodType<AdapterType, Response>> = new Set();
15
+ options?: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>;
18
16
 
19
17
  constructor(
20
- readonly socket: Socket<AdapterType>,
21
- readonly listenerOptions?: ListenerOptionsType<Endpoint, AdapterType>,
18
+ readonly socket: Socket,
19
+ readonly listenerOptions: ListenerOptionsType<Topic, ExtractSocketAdapterType<Socket>>,
22
20
  ) {
23
- const { endpoint, options } = listenerOptions;
24
- this.endpoint = endpoint;
21
+ const { topic, options } = listenerOptions;
22
+ this.topic = topic;
25
23
  this.options = options;
26
24
  }
27
25
 
28
- setOptions(options: ExtractListenerOptionsType<AdapterType>) {
26
+ setOptions(options: ExtractAdapterListenerOptionsType<ExtractSocketAdapterType<Socket>>) {
29
27
  return this.clone({ options });
30
28
  }
31
29
 
32
- setParams(params: ExtractRouteParams<Endpoint>) {
30
+ setParams(params: ExtractRouteParams<Topic>) {
33
31
  return this.clone<true>({ params });
34
32
  }
35
33
 
36
- private paramsMapper = (params: ParamsType | null | undefined): Endpoint => {
37
- let endpoint = this.listenerOptions.endpoint as string;
38
- if (params) {
39
- Object.entries(params).forEach(([key, value]) => {
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
- endpoint: this.paramsMapper(options?.params || this.params),
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<this, AdapterType> = ({ callback, ...options }) => {
68
- const instance = this.clone(options);
69
-
70
- const action = (response: { data: Response; extra: ExtractSocketExtraType<AdapterType> }) => {
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(instance.endpoint, action);
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, NegativeTypes } from "@hyper-fetch/core";
1
+ import { ExtractRouteParams, EmptyTypes, TypeWithDefaults } from "@hyper-fetch/core";
2
2
 
3
- import { SocketAdapterInstance, ExtractListenerOptionsType, ListenerCallbackType, SocketAdapterType } from "adapter";
3
+ import { SocketAdapterInstance } from "adapter";
4
4
  import { Listener } from "listener";
5
- import { ExtractListenerHasParams, ExtractListenerEndpointType, ExtractListenerResponseType } from "types";
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 ListenerInstance = Listener<any, any, SocketAdapterInstance, any>;
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<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
10
- endpoint: Endpoint;
11
- params?: ExtractRouteParams<Endpoint>;
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 ListenType<Listener extends ListenerInstance, Adapter extends SocketAdapterType> = (
16
- options: ExtractRouteParams<ExtractListenerEndpointType<Listener>> extends NegativeTypes
17
- ? { callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>> }
18
- : ExtractListenerHasParams<Listener> extends false
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<ExtractListenerEndpointType<Listener>>;
21
- callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
42
+ params: ExtractRouteParams<ExtractListenerTopicType<Listener>>;
22
43
  }
23
44
  : {
24
45
  params?: never;
25
- callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
26
- },
27
- ) => () => void;
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
- getReconnectingStopKey,
12
- getListenerEventByEndpointKey,
13
- getEmitterEventByEndpointKey,
10
+ getReconnectingFailedKey,
11
+ getListenerEventByTopicKey,
14
12
  getListenerRemoveKey,
15
- getListenerRemoveByEndpointKey,
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 { ExtractSocketExtraType, SocketAdapterInstance } from "adapter";
21
+ import { SocketAdapterInstance } from "adapter";
22
+ import { ExtractAdapterExtraType } from "types";
20
23
 
21
- export const getSocketEvents = <T extends SocketAdapterInstance>(eventEmitter: EventEmitter) => ({
22
- emitError: <ResponseType>(event: ResponseType): void => {
23
- eventEmitter.emit(getErrorKey(), event);
24
- },
25
- emitOpen: (): void => {
26
- eventEmitter.emit(getOpenKey());
27
- },
28
- emitClose: (): void => {
29
- eventEmitter.emit(getCloseKey());
30
- },
31
- emitConnecting: (): void => {
32
- eventEmitter.emit(getConnectingKey());
33
- },
34
- emitReconnecting: (attempts: number): void => {
35
- eventEmitter.emit(getReconnectingKey(), attempts);
36
- },
37
- emitReconnectingStop: (attempts: number): void => {
38
- eventEmitter.emit(getReconnectingStopKey(), attempts);
39
- },
40
- emitListenerEvent: <ResponseType>(
41
- endpoint: string,
42
- { data, extra }: { data: ResponseType; extra: ExtractSocketExtraType<T> },
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
- endpoint: string;
49
+ topic: string;
87
50
  data: ResponseType;
88
- extra: ExtractSocketExtraType<T>;
89
- }) => void,
90
- ): VoidFunction => {
91
- eventEmitter.on(getListenerEventKey(), callback);
92
- return () => eventEmitter.removeListener(getListenerEventKey(), callback);
93
- },
94
- onEmitterEvent: <EmitterType extends EmitterInstance>(callback: (emitter: EmitterType) => void): VoidFunction => {
95
- eventEmitter.on(getEmitterEventKey(), callback);
96
- return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
97
- },
98
- onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(
99
- listener: ListenerType,
100
- callback: ({
101
- endpoint,
102
- data,
103
- extra,
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
- endpoint: string;
106
- data: ResponseType;
107
- extra: ExtractSocketExtraType<T>;
108
- }) => void,
109
- ): VoidFunction => {
110
- eventEmitter.on(getListenerEventByEndpointKey(listener.endpoint), callback);
111
- return () => eventEmitter.removeListener(getListenerEventByEndpointKey(listener.endpoint), callback);
112
- },
113
- onListenerRemove: (callback: (endpoint: string) => void): VoidFunction => {
114
- eventEmitter.on(getListenerRemoveKey(), callback);
115
- return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
116
- },
117
- onListenerRemoveByEndpoint: <ListenerType extends ListenerInstance>(
118
- listener: ListenerType,
119
- callback: () => void,
120
- ): VoidFunction => {
121
- eventEmitter.on(getListenerRemoveByEndpointKey(listener.endpoint), callback);
122
- return () => eventEmitter.removeListener(getListenerRemoveByEndpointKey(listener.endpoint), callback);
123
- },
124
- onEmitterEventByEndpoint: <EmitterType extends EmitterInstance>(
125
- emitter: EmitterType,
126
- callback: (emitter: EmitterType) => void,
127
- ): VoidFunction => {
128
- eventEmitter.on(getEmitterEventByEndpointKey(emitter.endpoint), callback);
129
- return () => eventEmitter.removeListener(getEmitterEventByEndpointKey(emitter.endpoint), callback);
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;