@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.
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
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, NegativeTypes, QueryParamsType, LoggerManager, AppManager, QueryStringifyOptionsType, StringifyCallbackType, SeverityType } from '@hyper-fetch/core';
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
- type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any, any, any> ? P : never;
22
- type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any, any, any, any> ? R : never;
23
- type ExtractEmitterEndpointType<E> = E extends Emitter<any, any, infer A, any, any, any, any> ? A : never;
24
- type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, any, infer A, any, any, any> ? A : never;
25
- type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, any, infer M, any, any> ? M : never;
26
- type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, any, infer M, any> ? M : never;
27
- type ExtractEmitterHasDataType<E> = E extends Emitter<any, any, any, any, any, any, infer D> ? D : never;
28
- type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
29
- type ExtractListenerEndpointType<E> = E extends Listener<any, infer A, any, any> ? A : never;
30
- type ExtractListenerAdapterType<E> = E extends Listener<any, any, infer A, any> ? A : never;
31
- type ExtractListenerHasParams<E> = E extends Listener<any, any, any, infer P> ? P : never;
32
-
33
- type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0], unsubscribe: () => void) => void;
34
-
35
- declare class Emitter<Payload, Response, Endpoint extends string, AdapterType extends SocketAdapterType, MappedData = void, HasParams extends boolean = false, HasData extends boolean = false> {
36
- readonly socket: Socket<AdapterType>;
37
- readonly emitterOptions: EmitterOptionsType<Endpoint, AdapterType>;
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
- timeout: number;
42
- data: Payload | null;
43
- options: ExtractEmitterOptionsType<AdapterType>;
44
- connections: Set<ConnectMethodType<AdapterType, Response>>;
45
- constructor(socket: Socket<AdapterType>, emitterOptions: EmitterOptionsType<Endpoint, AdapterType>, json?: Partial<Emitter<Payload, Response, Endpoint, AdapterType, MappedData>>, dataMapper?: (data: Payload) => MappedData);
46
- setOptions(options: ExtractEmitterOptionsType<AdapterType>): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, HasParams, HasData>;
47
- setTimeout(timeout: number): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, HasParams, HasData>;
48
- setData(data: Payload): Emitter<MappedData, Response, Endpoint, AdapterType, MappedData, HasParams, true>;
49
- setDataMapper: <MapperData>(mapper: (data: Payload) => MapperData) => Emitter<Payload, Response, Endpoint, AdapterType, MapperData, HasParams, HasData>;
50
- setParams(params: ExtractRouteParams<Endpoint>): Emitter<Payload, Response, Endpoint, AdapterType, MappedData, true, HasData>;
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
- * Attach global logic to the received events
53
- * @param callback
18
+ * Used to recreate the emitter with the same state
19
+ * @internal
54
20
  */
55
- onData(callback: ConnectMethodType<AdapterType, Response>): this;
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 = Payload, MapperData = MappedData, Params extends boolean = HasParams, Data extends boolean = HasData>(options?: Partial<EmitterOptionsType<Endpoint, AdapterType>> & {
58
- params?: ParamsType;
59
- data?: NewPayload;
60
- }, mapper?: (data: NewPayload) => MapperData): Emitter<NewPayload, Response, Endpoint, AdapterType, MapperData, Params, Data>;
61
- getAck: (ack?: EmitterAcknowledgeType<any, AdapterType>) => (response: {
62
- data: any;
63
- extra: any;
64
- error: any;
65
- }) => void;
66
- emit: EmitType<this>;
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 EmitterInstance = Emitter<any, any, any, SocketAdapterInstance, any, any, any>;
70
- type EmitterOptionsType<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
71
- endpoint: Endpoint;
72
- timeout?: number;
73
- options?: ExtractEmitterOptionsType<AdapterType>;
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 EmitterAcknowledgeType<Response, AdapterType extends SocketAdapterInstance> = (response: {
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 EmitDataType<Payload, HasData extends boolean> = HasData extends false ? {
85
- data: Payload;
50
+ type EmitPayloadType<Payload, HasPayload extends boolean> = HasPayload extends false ? {
51
+ payload: Payload;
86
52
  } : {
87
- data?: never;
53
+ payload?: Payload;
88
54
  };
89
- type EmitParamsType<Params, HasData extends boolean> = HasData extends false ? Params extends NegativeTypes ? {
90
- params?: never;
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?: never;
60
+ params?: Params;
95
61
  };
96
- type EmitRestType<Emitter extends EmitterInstance> = {
97
- options?: Partial<EmitterOptionsType<ExtractEmitterEndpointType<Emitter>, ExtractEmitterAdapterType<Emitter>>>;
98
- ack?: EmitterAcknowledgeType<ExtractEmitterPayloadType<Emitter>, ExtractEmitterAdapterType<Emitter>>;
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
- type RemoveListenerCallbackType = () => void;
103
- type ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
104
- data: D;
105
- extra: ExtractSocketExtraType<AdapterType>;
106
- }) => void;
107
- type SocketAdapterType<AdapterOptions extends Record<string, any> = never, AdapterExtra extends Record<string, any> = Record<never, never>, ListenerOptions extends Record<string, any> = never, EmitterOptions extends Record<string, any> = never> = (socket: Socket<SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>, DO_NOT_USE?: {
108
- adapterOptions?: AdapterOptions;
109
- adapterExtra?: AdapterExtra;
110
- listenerOptions?: ListenerOptions;
111
- emitterOptions?: EmitterOptions;
112
- }) => {
113
- open: boolean;
114
- reconnectionAttempts: number;
115
- listeners: Map<string, Map<ListenerCallbackType<SocketAdapterInstance, any>, VoidFunction>>;
116
- listen: (listener: Listener<any, any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>, callback: ListenerCallbackType<SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>, any>) => RemoveListenerCallbackType;
117
- removeListener: (endpoint: string, callback: (...args: any) => void) => void;
118
- emit: (eventMessageId: string, emitter: EmitterInstance, ack?: EmitterAcknowledgeType<any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>) => void;
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
- type SocketAdapterInstance = SocketAdapterType<any, any, any, any>;
125
- type ExtractSocketOptionsType<T> = T extends SocketAdapterType<infer O, any, any, any> ? O : never;
126
- type ExtractSocketExtraType<T> = T extends SocketAdapterType<any, infer E, any, any> ? E : never;
127
- type ExtractListenerOptionsType<T> = T extends SocketAdapterType<any, any, infer O, any> ? O : never;
128
- type ExtractEmitterOptionsType<T> = T extends SocketAdapterType<any, any, any, infer E> ? E : never;
129
- type ExtractUnionSocket<Adapter extends SocketAdapterInstance, Values extends {
130
- adapterOptions?: any;
131
- adapterExtra?: any;
132
- listenerOptions?: any;
133
- emitterOptions?: any;
134
- }> = Extract<Adapter, SocketAdapterType<Values["adapterOptions"], Values["adapterExtra"], Values["listenerOptions"], Values["emitterOptions"]>> extends SocketAdapterInstance ? Extract<Adapter, SocketAdapterType<Values["adapterOptions"], Values["adapterExtra"], Values["listenerOptions"], Values["emitterOptions"]>> : never;
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
- endpoint: string;
152
- data: D;
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
- declare const getSocketAdapterBindings: <T extends SocketAdapterInstance>(socket: SocketInstance, defaults?: {
162
- open?: boolean;
163
- connecting?: boolean;
164
- forceClosed?: boolean;
165
- reconnectionAttempts?: number;
166
- }) => {
167
- open: boolean;
168
- connecting: boolean;
169
- reconnectionAttempts: number;
170
- forceClosed: boolean;
171
- onConnect: () => boolean;
172
- onReconnect: (disconnect: () => void, connect: () => void) => boolean;
173
- onDisconnect: () => boolean;
174
- onListen: (listener: Pick<ListenerInstance, "endpoint">, callback: ListenerCallbackType<T, any>, unmount?: VoidFunction) => (() => void);
175
- onEmit: (emitter: EmitterInstance) => boolean;
176
- onOpen: () => void;
177
- onClose: () => void;
178
- onError: (event: Error) => void;
179
- onEvent: (endpoint: string, response: any, resposeExtra: ExtractSocketExtraType<T>) => void;
180
- listeners: Map<string, Map<ListenerCallbackType<T, any>, VoidFunction>>;
181
- removeListener: (endpoint: string, callback: ListenerCallbackType<T, any>) => boolean;
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, Endpoint extends string, AdapterType extends SocketAdapterType, HasParams extends boolean = false> {
185
- readonly socket: Socket<AdapterType>;
186
- readonly listenerOptions?: ListenerOptionsType<Endpoint, AdapterType>;
187
- readonly endpoint: Endpoint;
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?: ExtractListenerOptionsType<AdapterType>;
190
- connections: Set<ConnectMethodType<AdapterType, Response>>;
191
- constructor(socket: Socket<AdapterType>, listenerOptions?: ListenerOptionsType<Endpoint, AdapterType>);
192
- setOptions(options: ExtractListenerOptionsType<AdapterType>): Listener<Response, Endpoint, AdapterType, HasParams>;
193
- setParams(params: ExtractRouteParams<Endpoint>): Listener<Response, Endpoint, AdapterType, true>;
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 ListenerInstance = Listener<any, any, SocketAdapterInstance, any>;
205
- type ListenerOptionsType<Endpoint extends string, AdapterType extends SocketAdapterInstance> = {
206
- endpoint: Endpoint;
207
- params?: ExtractRouteParams<Endpoint>;
208
- options?: ExtractListenerOptionsType<AdapterType>;
236
+ type ListenerInstanceProperties = {
237
+ response?: any;
238
+ topic?: string;
239
+ socket?: SocketInstance;
240
+ hasParams?: boolean;
209
241
  };
210
- type ListenType<Listener extends ListenerInstance, Adapter extends SocketAdapterType> = (options: ExtractRouteParams<ExtractListenerEndpointType<Listener>> extends NegativeTypes ? {
211
- callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
212
- } : ExtractListenerHasParams<Listener> extends false ? {
213
- params: ExtractRouteParams<ExtractListenerEndpointType<Listener>>;
214
- callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
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
- callback: ListenerCallbackType<Adapter, ExtractListenerResponseType<Listener>>;
218
- }) => () => void;
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
- declare class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
221
- options: SocketOptionsType<AdapterType>;
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: <ResponseType_1>(event: ResponseType_1) => void;
225
- emitOpen: () => void;
226
- emitClose: () => void;
227
- emitConnecting: () => void;
228
- emitReconnecting: (attempts: number) => void;
229
- emitReconnectingStop: (attempts: number) => void;
230
- emitListenerEvent: <ResponseType_2>(endpoint: string, { data, extra }: {
231
- data: ResponseType_2;
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: (endpoint: string) => void;
235
- emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
236
- onError: (callback: <ResponseType_3>(event: ResponseType_3) => void) => VoidFunction;
237
- onOpen: (callback: () => void) => VoidFunction;
238
- onClose: (callback: () => void) => VoidFunction;
239
- onConnecting: (callback: () => void) => VoidFunction;
240
- onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
241
- onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
242
- onListenerEvent: <ResponseType_4 = Event>(callback: ({ endpoint, data, extra, }: {
243
- endpoint: string;
244
- data: ResponseType_4;
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
- onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
248
- onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: ({ endpoint, data, extra, }: {
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: (endpoint: string) => void) => VoidFunction;
254
- onListenerRemoveByEndpoint: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
255
- onEmitterEventByEndpoint: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
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
- reconnect: number;
363
+ reconnectAttempts: number;
259
364
  reconnectTime: number;
260
- auth?: QueryParamsType | string;
261
- queryParams?: QueryParamsType | string;
262
365
  debug: boolean;
263
366
  autoConnect: boolean;
264
- __onOpenCallbacks: OpenCallbackType<Socket<AdapterType>>[];
265
- __onCloseCallbacks: CloseCallbackType<Socket<AdapterType>>[];
266
- __onReconnectCallbacks: ReconnectCallbackType<Socket<AdapterType>>[];
267
- __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<AdapterType>>[];
268
- __onMessageCallbacks: MessageCallbackType<Socket<AdapterType>, any>[];
269
- __onSendCallbacks: SendCallbackType<EmitterInstance>[];
270
- __onErrorCallbacks: ErrorCallbackType<Socket<AdapterType>, any>[];
271
- adapter: ReturnType<AdapterType>;
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
- queryParamsConfig?: QueryStringifyOptionsType;
275
- logger: _hyper_fetch_core.LoggerType;
377
+ logger: _hyper_fetch_core.LoggerMethods;
378
+ constructor(options: SocketOptionsType<Adapter>);
276
379
  /**
277
- * Method to stringify query params from objects.
380
+ * This method connects the socket to the server
278
381
  */
279
- queryParamsStringify: StringifyCallbackType;
280
- constructor(options: SocketOptionsType<AdapterType>);
382
+ connect: () => Promise<void>;
281
383
  /**
282
- * This method enables the logger usage and display the logs in console
384
+ * This method disconnects the socket from the server
283
385
  */
284
- setDebug: (debug: boolean) => this;
386
+ disconnect: () => Promise<void>;
285
387
  /**
286
- * Set the logger severity of the messages displayed to the console
388
+ * This method reconnect the socket to the server
287
389
  */
288
- setLoggerSeverity: (severity: SeverityType) => this;
390
+ reconnect: () => Promise<void>;
391
+ setQueryParams: (queryParams: ExtractAdapterQueryParamsType<Adapter>) => this;
289
392
  /**
290
- * Set the new logger instance to the socket
393
+ * This method enables the logger usage and display the logs in console
291
394
  */
292
- setLogger: (callback: (socket: Socket<AdapterType>) => LoggerManager) => this;
395
+ setDebug: (enabled: boolean) => this;
293
396
  /**
294
- * Set the new auth data to the socket
397
+ * Set the logger severity of the messages displayed to the console
295
398
  */
296
- setAuth: (auth: QueryParamsType | string) => this;
399
+ setLogLevel: (level: LogLevel) => this;
297
400
  /**
298
- * Set the new query data to the socket
401
+ * Set the new logger instance to the socket
299
402
  */
300
- setQuery: (queryParams: QueryParamsType | string) => this;
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
- onOpen(callback: OpenCallbackType<Socket<AdapterType>>): this;
412
+ onConnected(callback: OpenCallbackType): this;
310
413
  /**
311
414
  * Triggered when connection is closed
312
415
  * @param callback
313
416
  * @returns
314
417
  */
315
- onClose(callback: CloseCallbackType<Socket<AdapterType>>): this;
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<Socket<AdapterType>>): this;
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
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<AdapterType>>): this;
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 = ExtractSocketExtraType<AdapterType>>(callback: MessageCallbackType<Socket<AdapterType>, Event>): this;
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<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>): this;
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 = ExtractSocketExtraType<AdapterType>>(callback: ErrorCallbackType<Socket<AdapterType>, Event>): this;
448
+ onError<Event>(callback: ErrorCallbackType<Event>): this;
346
449
  /**
347
450
  * ********************
348
451
  * Interceptors
349
452
  * ********************
350
453
  */
351
- __modifySend: (emitter: EmitterInstance) => EmitterInstance;
352
- __modifyResponse: (data: {
454
+ unstable__modifySend: (emitter: EmitterInstance) => EmitterInstance;
455
+ unstable__modifyResponse: (data: {
353
456
  data: any;
354
- extra: ExtractSocketExtraType<AdapterType>;
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: <Response_1>() => <Endpoint extends string>(options: ListenerOptionsType<Endpoint, AdapterType>) => Listener<Response_1, Endpoint, AdapterType, false>;
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, Response_1 = never>() => <Endpoint extends string>(options: EmitterOptionsType<Endpoint, AdapterType>) => Emitter<Payload, Response_1, Endpoint, AdapterType, void, false, false>;
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<AdapterType extends SocketAdapterInstance> = {
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
- queryParams?: QueryParamsType | string;
386
- autoConnect?: boolean;
387
- queryParamsConfig?: QueryStringifyOptionsType;
388
- queryParamsStringify?: StringifyCallbackType;
389
- adapterOptions?: ExtractSocketOptionsType<AdapterType>;
486
+ adapter?: (() => Adapter) | Adapter;
487
+ adapterOptions?: ExtractAdapterOptionsType<Adapter>;
488
+ queryParams?: ExtractAdapterQueryParamsType<Adapter>;
390
489
  };
391
- type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
392
- type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
393
- type OpenCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
394
- type CloseCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
395
- type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
396
- type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
397
- type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
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 getReconnectingStopKey: () => string;
509
+ declare const getReconnectingFailedKey: () => string;
405
510
  declare const getListenerEventKey: () => string;
406
511
  declare const getListenerRemoveKey: () => string;
407
- declare const getEmitterEventKey: () => string;
408
- declare const getListenerRemoveByEndpointKey: (event: string) => string;
409
- declare const getListenerEventByEndpointKey: (event: string) => string;
410
- declare const getEmitterEventByEndpointKey: (event: string) => string;
411
- declare const interceptListener: <Socket extends SocketInstance>(interceptors: MessageCallbackType<Socket, any>[], data: {
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
- }, socket: Socket) => {
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: <T extends SocketAdapterInstance>(eventEmitter: EventEmitter) => {
421
- emitError: <ResponseType_1>(event: ResponseType_1) => void;
422
- emitOpen: () => void;
423
- emitClose: () => void;
424
- emitConnecting: () => void;
425
- emitReconnecting: (attempts: number) => void;
426
- emitReconnectingStop: (attempts: number) => void;
427
- emitListenerEvent: <ResponseType_2>(endpoint: string, { data, extra }: {
428
- data: ResponseType_2;
429
- extra: ExtractSocketExtraType<T>;
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
- emitListenerRemoveEvent: (endpoint: string) => void;
432
- emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
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
- onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
445
- onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: ({ endpoint, data, extra, }: {
446
- endpoint: string;
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: ExtractSocketExtraType<T>;
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
- export { CloseCallbackType, ConnectMethodType, EmitDataType, EmitParamsType, EmitRestType, EmitType, Emitter, EmitterAcknowledgeType, EmitterInstance, EmitterOptionsType, ErrorCallbackType, ExtractEmitterAdapterType, ExtractEmitterEndpointType, ExtractEmitterHasDataType, ExtractEmitterHasParamsType, ExtractEmitterMappedDataType, ExtractEmitterOptionsType, ExtractEmitterPayloadType, ExtractEmitterResponseType, ExtractListenerAdapterType, ExtractListenerEndpointType, ExtractListenerHasParams, ExtractListenerOptionsType, ExtractListenerResponseType, ExtractSocketExtraType, ExtractSocketOptionsType, ExtractUnionSocket, ListenType, Listener, ListenerCallbackType, ListenerInstance, ListenerOptionsType, MessageCallbackType, OpenCallbackType, ReconnectCallbackType, ReconnectStopCallbackType, RemoveListenerCallbackType, SSEAdapterOptionsType, SSEAdapterType, SendCallbackType, Socket, SocketAdapterInstance, SocketAdapterType, SocketData, SocketInstance, SocketOptionsType, TupleRestType, WSAdapterOptionsType, WSMessageType, WebsocketAdapterType, getCloseKey, getConnectingKey, getEmitterEventByEndpointKey, getEmitterEventKey, getErrorKey, getListenerEventByEndpointKey, getListenerEventKey, getListenerRemoveByEndpointKey, getListenerRemoveKey, getOpenKey, getReconnectingKey, getReconnectingStopKey, getSSEAdapter, getSocketAdapterBindings, getSocketEvents, getSocketUrl, getWebsocketAdapter, interceptEmitter, interceptListener, sseAdapter, websocketAdapter };
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 };