@hyper-fetch/sockets 3.1.0 → 3.2.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.
@@ -1,28 +0,0 @@
1
- import { LoggerType } from "@hyper-fetch/core";
2
- import { EmitterInstance } from "emitter";
3
- import { ListenerInstance } from "listener";
4
- import { SocketInstance } from "socket";
5
- import { ListenerCallbackType, WSMessageType } from "adapter";
6
- export declare class SocketAdapter<SocketType extends SocketInstance> {
7
- readonly socket: SocketType;
8
- adapter: WebSocket | EventSource | undefined;
9
- listeners: Map<string, Set<ListenerCallbackType>>;
10
- open: boolean;
11
- connecting: boolean;
12
- forceClosed: boolean;
13
- reconnectionAttempts: number;
14
- pingTimer: ReturnType<typeof setTimeout> | undefined;
15
- pongTimer: ReturnType<typeof setTimeout> | undefined;
16
- init: () => WebSocket | EventSource;
17
- logger: LoggerType;
18
- constructor(socket: SocketType);
19
- connect: () => void;
20
- disconnect: () => void;
21
- reconnect: () => boolean;
22
- clearTimers: () => void;
23
- sendEventMessage: (payload: WSMessageType) => void;
24
- heartbeat: () => void;
25
- removeListener: (event: string, callback: (data: any, event: MessageEvent<any>) => void) => boolean;
26
- listen: (listener: Pick<ListenerInstance, "name">, callback: (data: any, event: MessageEvent<any>) => void) => () => boolean;
27
- emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: MessageEvent<any>) => void) => Promise<void>;
28
- }
@@ -1,31 +0,0 @@
1
- import { EmitterInstance } from "emitter";
2
- import { ListenerInstance } from "listener";
3
- export type RemoveListenerCallbackType = () => void;
4
- export type ListenerCallbackType<D = any> = (data: D, event: MessageEvent<D>) => void;
5
- export type AdapterType = {
6
- connecting: boolean;
7
- listeners: Map<string, Set<ListenerCallbackType>>;
8
- emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: any) => void) => void;
9
- listen: (listener: ListenerInstance, callback: ListenerCallbackType) => RemoveListenerCallbackType;
10
- removeListener: (name: string, callback: (...args: any) => void) => void;
11
- connect: () => void;
12
- reconnect: () => void;
13
- disconnect: () => void;
14
- };
15
- export type SSEAdapterOptionsType = {
16
- eventSourceInit?: EventSourceInit;
17
- reconnectTimeout?: number;
18
- };
19
- export type WSAdapterOptionsType = {
20
- protocols?: string[];
21
- pingTimeout?: number;
22
- pongTimeout?: number;
23
- reconnectTimeout?: number;
24
- heartbeatMessage?: string;
25
- heartbeat?: boolean;
26
- };
27
- export type WSMessageType = {
28
- id: string;
29
- name: string;
30
- data: string;
31
- };
@@ -1,2 +0,0 @@
1
- import { SocketInstance } from "socket";
2
- export declare const getAdapter: (socket: SocketInstance) => WebSocket | EventSource;
@@ -1,3 +0,0 @@
1
- export * from "./adapter";
2
- export * from "./adapter.types";
3
- export * from "./adapter.utils";
@@ -1,20 +0,0 @@
1
- import { Socket } from "socket";
2
- import { EmitterOptionsType, EmitterCloneOptionsType } from "emitter";
3
- import { AdapterType } from "adapter";
4
- import { ExtractEmitterOptionsType } from "types/extract.types";
5
- export declare class Emitter<Payload, Response, Adapter extends AdapterType, MappedData = void> {
6
- readonly socket: Socket<Adapter>;
7
- readonly emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<Adapter>>;
8
- readonly dataMapper?: (data: Payload) => MappedData;
9
- readonly name: string;
10
- timeout: number;
11
- data: Payload | null;
12
- options: ExtractEmitterOptionsType<Adapter>;
13
- constructor(socket: Socket<Adapter>, emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<Adapter>>, dump?: Partial<Emitter<Payload, Response, Adapter, MappedData>>, dataMapper?: (data: Payload) => MappedData);
14
- setOptions(options: ExtractEmitterOptionsType<Adapter>): Emitter<Payload, Response, Adapter, MappedData>;
15
- setTimeout(timeout: number): Emitter<Payload, Response, Adapter, MappedData>;
16
- setData(data: Payload): any;
17
- setDataMapper: <MapperData>(mapper: (data: Payload) => MapperData) => Emitter<Payload, Response, Adapter, MapperData>;
18
- clone<NewPayload = Payload, MapperData = MappedData>(config?: Partial<EmitterCloneOptionsType<NewPayload, ExtractEmitterOptionsType<Adapter>>>, mapper?: (data: NewPayload) => MapperData): Emitter<NewPayload, Response, Adapter, MapperData>;
19
- emit(options?: Partial<EmitterCloneOptionsType<Payload, ExtractEmitterOptionsType<Adapter>>>, ack?: (error: Error | null, response: Response) => void): string;
20
- }
@@ -1,10 +0,0 @@
1
- import { Emitter } from "emitter";
2
- export type EmitterInstance = Emitter<any, any, any>;
3
- export type EmitterOptionsType<AdditionalEmitterOptions> = {
4
- name: string;
5
- timeout?: number;
6
- options?: AdditionalEmitterOptions;
7
- };
8
- export type EmitterCloneOptionsType<DataType, AdditionalEmitterOptions> = Partial<EmitterOptionsType<AdditionalEmitterOptions>> & {
9
- data: DataType;
10
- };
@@ -1,2 +0,0 @@
1
- export * from "./emitter";
2
- export * from "./emitter.types";
@@ -1,2 +0,0 @@
1
- export * from "./listener";
2
- export * from "./listener.types";
@@ -1,14 +0,0 @@
1
- import { Socket } from "socket";
2
- import { ListenerOptionsType } from "listener";
3
- import { ListenerCallbackType, AdapterType } from "adapter";
4
- import { ExtractListenerOptionsType } from "types/extract.types";
5
- export declare class Listener<Response, Adapter extends AdapterType> {
6
- readonly socket: Socket<Adapter>;
7
- readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<Adapter>>;
8
- readonly name: string;
9
- options?: ExtractListenerOptionsType<Adapter>;
10
- constructor(socket: Socket<Adapter>, listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<Adapter>>);
11
- setOptions(options: ExtractListenerOptionsType<Adapter>): Listener<Response, Adapter>;
12
- clone(config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<Adapter>>>): Listener<Response, Adapter>;
13
- listen(callback: (data: ListenerCallbackType<Response>) => void): readonly [() => void, (data: ListenerCallbackType<Response>) => void];
14
- }
@@ -1,6 +0,0 @@
1
- import { Listener } from "listener";
2
- export type ListenerInstance = Listener<any, any>;
3
- export type ListenerOptionsType<SocketOptions> = {
4
- name: string;
5
- options?: SocketOptions;
6
- };
@@ -1,4 +0,0 @@
1
- export * from "./socket";
2
- export * from "./socket.types";
3
- export * from "./socket.utils";
4
- export * from "./socket.events";
@@ -1,147 +0,0 @@
1
- /// <reference types="node" />
2
- import EventEmitter from "events";
3
- import { StringifyCallbackType, QueryStringifyOptionsType, LoggerManager, SeverityType, AppManager, QueryParamsType } from "@hyper-fetch/core";
4
- import { SocketAdapterOptionsType, ReconnectCallbackType, ReconnectStopCallbackType, OpenCallbackType, CloseCallbackType, MessageCallbackType, SendCallbackType, ErrorCallbackType } from "socket";
5
- import { AdapterType } from "adapter";
6
- import { Listener, ListenerOptionsType } from "listener";
7
- import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
8
- export declare class Socket<Adapter extends Record<keyof AdapterType, any>> {
9
- options: SocketAdapterOptionsType<Adapter>;
10
- emitter: EventEmitter;
11
- events: {
12
- emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
13
- emitOpen: () => void;
14
- emitClose: () => void;
15
- emitConnecting: () => void;
16
- emitReconnecting: (attempts: number) => void;
17
- emitReconnectingStop: (attempts: number) => void;
18
- emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
19
- emitListenerRemoveEvent: (name: string) => void;
20
- emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
21
- onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
22
- onOpen: (callback: () => void) => VoidFunction;
23
- onClose: (callback: () => void) => VoidFunction;
24
- onConnecting: (callback: () => void) => VoidFunction;
25
- onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
26
- onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
27
- onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
28
- onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
29
- onListenerEventByName: <ListenerType extends import("listener").ListenerInstance>(listener: ListenerType, callback: (data: import("..").ExtractListenerResponseType<ListenerType>, event: MessageEvent<import("..").ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
30
- onListenerRemove: (callback: (name: string) => void) => VoidFunction;
31
- onListenerRemoveByName: <ListenerType_1 extends import("listener").ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
32
- onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
33
- };
34
- url: string;
35
- reconnect: number;
36
- reconnectTime: number;
37
- auth?: QueryParamsType | string;
38
- queryParams?: QueryParamsType | string;
39
- debug: boolean;
40
- autoConnect: boolean;
41
- __onOpenCallbacks: OpenCallbackType<Socket<Adapter>, any>[];
42
- __onCloseCallbacks: CloseCallbackType<Socket<Adapter>, any>[];
43
- __onReconnectCallbacks: ReconnectCallbackType<Socket<Adapter>>[];
44
- __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<Adapter>>[];
45
- __onMessageCallbacks: MessageCallbackType<Socket<Adapter>, any>[];
46
- __onSendCallbacks: SendCallbackType<EmitterInstance>[];
47
- __onErrorCallbacks: ErrorCallbackType<Socket<Adapter>, any>[];
48
- adapter: Adapter;
49
- loggerManager: LoggerManager;
50
- appManager: AppManager;
51
- queryParamsConfig?: QueryStringifyOptionsType;
52
- logger: LoggerType;
53
- /**
54
- * Method to stringify query params from objects.
55
- */
56
- queryParamsStringify: StringifyCallbackType;
57
- constructor(options: SocketAdapterOptionsType<Adapter>);
58
- /**
59
- * This method enables the logger usage and display the logs in console
60
- */
61
- setDebug: (debug: boolean) => this;
62
- /**
63
- * Set the logger severity of the messages displayed to the console
64
- */
65
- setLoggerSeverity: (severity: SeverityType) => this;
66
- /**
67
- * Set the new logger instance to the socket
68
- */
69
- setLogger: (callback: (socket: Socket<Adapter>) => LoggerManager) => this;
70
- /**
71
- * Set the new auth data to the socket
72
- */
73
- setAuth: (auth: QueryParamsType | string) => this;
74
- /**
75
- * Set the new query data to the socket
76
- */
77
- setQuery: (queryParams: QueryParamsType | string) => this;
78
- /**
79
- * Callbacks
80
- */
81
- /**
82
- * Triggered when connection is opened
83
- * @param callback
84
- * @returns
85
- */
86
- onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<Adapter>, Event>): this;
87
- /**
88
- * Triggered when connection is closed
89
- * @param callback
90
- * @returns
91
- */
92
- onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<Adapter>, Event>): this;
93
- /**
94
- * Triggered when connection is getting reconnected
95
- * @param callback
96
- * @returns
97
- */
98
- onReconnect(callback: ReconnectCallbackType<Socket<Adapter>>): this;
99
- /**
100
- * Triggered when connection attempts are stopped
101
- * @param callback
102
- * @returns
103
- */
104
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<Adapter>>): this;
105
- /**
106
- * Triggered when any message is received
107
- * @param callback
108
- * @returns
109
- */
110
- onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<Adapter>, Event>): this;
111
- /**
112
- * Triggered when any event is emitted
113
- * @param callback
114
- * @returns
115
- */
116
- onSend<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>): this;
117
- /**
118
- * Triggered when we receive error
119
- * @param callback
120
- * @returns
121
- */
122
- onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<Adapter>, Event>): this;
123
- /**
124
- * ********************
125
- * Interceptors
126
- * ********************
127
- */
128
- __modifySend: (emitter: EmitterInstance) => EmitterInstance;
129
- __modifyResponse: (response: MessageEvent) => MessageEvent<any>;
130
- /**
131
- * ********************
132
- * Creators
133
- * ********************
134
- */
135
- /**
136
- * Create event listener
137
- * @param options
138
- * @returns
139
- */
140
- createListener: <Response_1>(options: ListenerOptionsType<Adapter>) => Listener<Response_1, Adapter>;
141
- /**
142
- * Create event emitter
143
- * @param options
144
- * @returns
145
- */
146
- createEmitter: <Payload, Response_1 = never>(options: EmitterOptionsType<Adapter>) => Emitter<Payload, Response_1, Adapter, void>;
147
- }
@@ -1,27 +0,0 @@
1
- import EventEmitter from "events";
2
- import { EmitterInstance } from "emitter";
3
- import { ListenerInstance } from "listener";
4
- import { ExtractListenerResponseType } from "types/extract.types";
5
- export declare const getSocketEvents: (eventEmitter: EventEmitter) => {
6
- emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
7
- emitOpen: () => void;
8
- emitClose: () => void;
9
- emitConnecting: () => void;
10
- emitReconnecting: (attempts: number) => void;
11
- emitReconnectingStop: (attempts: number) => void;
12
- emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
13
- emitListenerRemoveEvent: (name: string) => void;
14
- emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
15
- onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
16
- onOpen: (callback: () => void) => VoidFunction;
17
- onClose: (callback: () => void) => VoidFunction;
18
- onConnecting: (callback: () => void) => VoidFunction;
19
- onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
20
- onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
21
- onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
22
- onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
23
- onListenerEventByName: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: (data: ExtractListenerResponseType<ListenerType>, event: MessageEvent<ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
24
- onListenerRemove: (callback: (name: string) => void) => VoidFunction;
25
- onListenerRemoveByName: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
26
- onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
27
- };
@@ -1,29 +0,0 @@
1
- import { QueryParamsType, QueryStringifyOptionsType, StringifyCallbackType } from "@hyper-fetch/core";
2
- import { Socket } from "socket";
3
- import { SSEAdapterOptionsType, WSAdapterOptionsType } from "adapter";
4
- import { EmitterInstance } from "emitter";
5
- export type SocketInstance = Socket<any>;
6
- export type SocketOptionsType<SocketAdapterType> = {
7
- url: string;
8
- adapter?: SocketAdapterType;
9
- auth?: QueryParamsType;
10
- queryParams?: QueryParamsType | string;
11
- reconnect?: number;
12
- reconnectTime?: number;
13
- autoConnect?: boolean;
14
- queryParamsConfig?: QueryStringifyOptionsType;
15
- queryParamsStringify?: StringifyCallbackType;
16
- };
17
- export type SocketAdapterOptionsType<SocketAdapterType> = (SocketOptionsType<SocketAdapterType> & {
18
- isSSE: true;
19
- adapterOptions?: SSEAdapterOptionsType;
20
- }) | (SocketOptionsType<SocketAdapterType> & {
21
- adapterOptions?: WSAdapterOptionsType;
22
- });
23
- export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
24
- export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
25
- export type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
26
- export type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
27
- export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
28
- export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
29
- export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
@@ -1,16 +0,0 @@
1
- import { EmitterInstance } from "emitter";
2
- import { MessageCallbackType, SendCallbackType, SocketInstance } from "./socket.types";
3
- export declare const getErrorKey: () => string;
4
- export declare const getOpenKey: () => string;
5
- export declare const getCloseKey: () => string;
6
- export declare const getConnectingKey: () => string;
7
- export declare const getReconnectingKey: () => string;
8
- export declare const getReconnectingStopKey: () => string;
9
- export declare const getListenerEventKey: () => string;
10
- export declare const getListenerRemoveKey: () => string;
11
- export declare const getEmitterEventKey: () => string;
12
- export declare const getListenerRemoveByNameKey: (event: string) => string;
13
- export declare const getListenerEventByNameKey: (event: string) => string;
14
- export declare const getEmitterEventByNameKey: (event: string) => string;
15
- export declare const interceptListener: <Socket extends SocketInstance>(interceptors: MessageCallbackType<Socket, MessageEvent<any>>[], response: MessageEvent, socket: Socket) => MessageEvent<any>;
16
- export declare const interceptEmitter: <EmitterType extends EmitterInstance>(interceptors: SendCallbackType<EmitterType>[], emitter: EmitterType) => EmitterType;
@@ -1,11 +0,0 @@
1
- import { AdapterType } from "adapter";
2
- import { Emitter } from "emitter";
3
- import { Listener } from "listener";
4
- export type ExtractEmitterOptionsType<E extends Record<keyof AdapterType | string, any>> = E["emitterOptions"];
5
- export type ExtractListenerOptionsType<E extends Record<keyof AdapterType | string, any>> = E["listenerOptions"];
6
- export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any> ? P : never;
7
- export type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any> ? R : never;
8
- export type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, infer A, any> ? A : never;
9
- export type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, infer M> ? M : never;
10
- export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
11
- export type ExtractListenerAdapterType<E> = E extends Listener<any, infer A> ? A : never;
@@ -1,2 +0,0 @@
1
- export * from "./tuple.types";
2
- export * from "./extract.types";
@@ -1 +0,0 @@
1
- export type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];