@hyper-fetch/sockets 1.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 (46) hide show
  1. package/.eslintrc.json +7 -0
  2. package/README.md +76 -0
  3. package/dist/client/client.d.ts +28 -0
  4. package/dist/client/client.types.d.ts +30 -0
  5. package/dist/client/client.utils.d.ts +2 -0
  6. package/dist/client/index.d.ts +3 -0
  7. package/dist/emitter/emitter.d.ts +20 -0
  8. package/dist/emitter/emitter.types.d.ts +10 -0
  9. package/dist/emitter/index.d.ts +2 -0
  10. package/dist/index.cjs.js +2 -0
  11. package/dist/index.cjs.js.map +7 -0
  12. package/dist/index.d.ts +5 -0
  13. package/dist/index.esm.js +2 -0
  14. package/dist/index.esm.js.map +7 -0
  15. package/dist/listener/index.d.ts +2 -0
  16. package/dist/listener/listener.d.ts +14 -0
  17. package/dist/listener/listener.types.d.ts +6 -0
  18. package/dist/socket/index.d.ts +4 -0
  19. package/dist/socket/socket.d.ts +139 -0
  20. package/dist/socket/socket.events.d.ts +27 -0
  21. package/dist/socket/socket.types.d.ts +29 -0
  22. package/dist/socket/socket.utils.d.ts +16 -0
  23. package/dist/types/extract.types.d.ts +7 -0
  24. package/dist/types/index.d.ts +2 -0
  25. package/dist/types/tuple.types.d.ts +1 -0
  26. package/package.json +65 -0
  27. package/src/client/client.ts +230 -0
  28. package/src/client/client.types.ts +36 -0
  29. package/src/client/client.utils.ts +15 -0
  30. package/src/client/index.ts +3 -0
  31. package/src/emitter/emitter.ts +77 -0
  32. package/src/emitter/emitter.types.ts +15 -0
  33. package/src/emitter/index.ts +2 -0
  34. package/src/index.ts +5 -0
  35. package/src/listener/index.ts +2 -0
  36. package/src/listener/listener.ts +44 -0
  37. package/src/listener/listener.types.ts +8 -0
  38. package/src/socket/index.ts +4 -0
  39. package/src/socket/socket.events.ts +119 -0
  40. package/src/socket/socket.ts +235 -0
  41. package/src/socket/socket.types.ts +33 -0
  42. package/src/socket/socket.utils.ts +43 -0
  43. package/src/types/extract.types.ts +16 -0
  44. package/src/types/index.ts +2 -0
  45. package/src/types/tuple.types.ts +1 -0
  46. package/tsconfig.json +8 -0
@@ -0,0 +1,2 @@
1
+ export * from "./emitter";
2
+ export * from "./emitter.types";
package/src/index.ts ADDED
@@ -0,0 +1,5 @@
1
+ export * from "./socket";
2
+ export * from "./client";
3
+ export * from "./emitter";
4
+ export * from "./listener";
5
+ export * from "./types";
@@ -0,0 +1,2 @@
1
+ export * from "./listener";
2
+ export * from "./listener.types";
@@ -0,0 +1,44 @@
1
+ import { Socket } from "socket";
2
+ import { ListenerOptionsType } from "listener";
3
+ import { ListenerCallbackType, WebsocketClientType } from "client";
4
+ import { ExtractListenerOptionsType } from "types/extract.types";
5
+
6
+ export class Listener<ResponseType, ClientType extends WebsocketClientType> {
7
+ readonly name: string;
8
+ options?: ExtractListenerOptionsType<ClientType>;
9
+
10
+ constructor(
11
+ readonly socket: Socket<ClientType>,
12
+ readonly listenerOptions?: ListenerOptionsType<ExtractListenerOptionsType<ClientType>>,
13
+ ) {
14
+ const { name, options } = listenerOptions;
15
+ this.name = name;
16
+ this.options = options;
17
+ }
18
+
19
+ setOptions(options: ExtractListenerOptionsType<ClientType>) {
20
+ return this.clone({ options });
21
+ }
22
+
23
+ clone(
24
+ config?: Partial<ListenerOptionsType<ExtractListenerOptionsType<ClientType>>>,
25
+ ): Listener<ResponseType, ClientType> {
26
+ return new Listener<ResponseType, ClientType>(this.socket, {
27
+ ...this.listenerOptions,
28
+ ...config,
29
+ name: this.name,
30
+ });
31
+ }
32
+
33
+ listen(callback: (data: ListenerCallbackType<ResponseType>) => void) {
34
+ const instance = this.clone();
35
+
36
+ this.socket.client.listen(instance, callback);
37
+
38
+ const removeListener = () => {
39
+ this.socket.client.removeListener(instance.name, callback);
40
+ };
41
+
42
+ return [removeListener, callback] as const;
43
+ }
44
+ }
@@ -0,0 +1,8 @@
1
+ import { Listener } from "listener";
2
+
3
+ export type ListenerInstance = Listener<any, any>;
4
+
5
+ export type ListenerOptionsType<SocketOptions> = {
6
+ name: string;
7
+ options?: SocketOptions;
8
+ };
@@ -0,0 +1,4 @@
1
+ export * from "./socket";
2
+ export * from "./socket.types";
3
+ export * from "./socket.utils";
4
+ export * from "./socket.events";
@@ -0,0 +1,119 @@
1
+ import EventEmitter from "events";
2
+
3
+ import {
4
+ getErrorKey,
5
+ getCloseKey,
6
+ getConnectingKey,
7
+ getEmitterEventKey,
8
+ getListenerEventKey,
9
+ getOpenKey,
10
+ getReconnectingKey,
11
+ getReconnectingStopKey,
12
+ getListenerEventByNameKey,
13
+ getEmitterEventByNameKey,
14
+ getListenerRemoveKey,
15
+ getListenerRemoveByNameKey,
16
+ } from "socket";
17
+ import { EmitterInstance } from "emitter";
18
+ import { ListenerInstance } from "listener";
19
+ import { ExtractListenerResponseType } from "types/extract.types";
20
+
21
+ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
22
+ emitError: <ResponseType = MessageEvent>(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 = MessageEvent>(
41
+ name: string,
42
+ data: ResponseType,
43
+ event: MessageEvent<ResponseType>,
44
+ ): void => {
45
+ eventEmitter.emit(getListenerEventKey(), data, event);
46
+ eventEmitter.emit(getListenerEventByNameKey(name), data, event);
47
+ },
48
+ emitListenerRemoveEvent: (name: string): void => {
49
+ eventEmitter.emit(getListenerRemoveKey(), name);
50
+ eventEmitter.emit(getListenerRemoveByNameKey(name));
51
+ },
52
+ emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType): void => {
53
+ eventEmitter.emit(getEmitterEventKey(), emitter);
54
+ eventEmitter.emit(getEmitterEventByNameKey(emitter.name), emitter);
55
+ },
56
+
57
+ onError: (callback: <ResponseType = MessageEvent>(event: ResponseType) => void): VoidFunction => {
58
+ eventEmitter.on(getErrorKey(), callback);
59
+ return () => eventEmitter.removeListener(getErrorKey(), callback);
60
+ },
61
+ onOpen: (callback: () => void): VoidFunction => {
62
+ eventEmitter.on(getOpenKey(), callback);
63
+ return () => eventEmitter.removeListener(getOpenKey(), callback);
64
+ },
65
+ onClose: (callback: () => void): VoidFunction => {
66
+ eventEmitter.on(getCloseKey(), callback);
67
+ return () => eventEmitter.removeListener(getCloseKey(), callback);
68
+ },
69
+ onConnecting: (callback: () => void): VoidFunction => {
70
+ eventEmitter.on(getConnectingKey(), callback);
71
+ return () => eventEmitter.removeListener(getConnectingKey(), callback);
72
+ },
73
+ onReconnecting: (callback: (attempts: number) => void): VoidFunction => {
74
+ eventEmitter.on(getReconnectingKey(), callback);
75
+ return () => eventEmitter.removeListener(getReconnectingKey(), callback);
76
+ },
77
+ onReconnectingStop: (callback: (attempts: number) => void): VoidFunction => {
78
+ eventEmitter.on(getReconnectingStopKey(), callback);
79
+ return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
80
+ },
81
+ onListenerEvent: <ResponseType = Event>(
82
+ callback: (data: ResponseType, event: MessageEvent<ResponseType>) => void,
83
+ ): VoidFunction => {
84
+ eventEmitter.on(getListenerEventKey(), callback);
85
+ return () => eventEmitter.removeListener(getListenerEventKey(), callback);
86
+ },
87
+ onEmitterEvent: <EmitterType extends EmitterInstance>(callback: (emitter: EmitterType) => void): VoidFunction => {
88
+ eventEmitter.on(getEmitterEventKey(), callback);
89
+ return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
90
+ },
91
+ onListenerEventByName: <ListenerType extends ListenerInstance>(
92
+ listener: ListenerType,
93
+ callback: (
94
+ data: ExtractListenerResponseType<ListenerType>,
95
+ event: MessageEvent<ExtractListenerResponseType<ListenerType>>,
96
+ ) => void,
97
+ ): VoidFunction => {
98
+ eventEmitter.on(getListenerEventByNameKey(listener.name), callback);
99
+ return () => eventEmitter.removeListener(getListenerEventByNameKey(listener.name), callback);
100
+ },
101
+ onListenerRemove: (callback: (name: string) => void): VoidFunction => {
102
+ eventEmitter.on(getListenerRemoveKey(), callback);
103
+ return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
104
+ },
105
+ onListenerRemoveByName: <ListenerType extends ListenerInstance>(
106
+ listener: ListenerType,
107
+ callback: () => void,
108
+ ): VoidFunction => {
109
+ eventEmitter.on(getListenerRemoveByNameKey(listener.name), callback);
110
+ return () => eventEmitter.removeListener(getListenerRemoveByNameKey(listener.name), callback);
111
+ },
112
+ onEmitterEventByName: <EmitterType extends EmitterInstance>(
113
+ emitter: EmitterType,
114
+ callback: (emitter: EmitterType) => void,
115
+ ): VoidFunction => {
116
+ eventEmitter.on(getEmitterEventByNameKey(emitter.name), callback);
117
+ return () => eventEmitter.removeListener(getEmitterEventByNameKey(emitter.name), callback);
118
+ },
119
+ });
@@ -0,0 +1,235 @@
1
+ import EventEmitter from "events";
2
+ import {
3
+ stringifyQueryParams,
4
+ StringifyCallbackType,
5
+ QueryStringifyOptions,
6
+ LoggerManager,
7
+ SeverityType,
8
+ AppManager,
9
+ DateInterval,
10
+ ClientQueryParamsType,
11
+ } from "@hyper-fetch/core";
12
+
13
+ import {
14
+ SocketConfig,
15
+ ReconnectCallbackType,
16
+ ReconnectStopCallbackType,
17
+ OpenCallbackType,
18
+ CloseCallbackType,
19
+ MessageCallbackType,
20
+ SendCallbackType,
21
+ ErrorCallbackType,
22
+ getSocketEvents,
23
+ interceptListener,
24
+ interceptEmitter,
25
+ } from "socket";
26
+ import { WebsocketClientType, SocketClient } from "client";
27
+ import { Listener, ListenerOptionsType } from "listener";
28
+ import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
29
+
30
+ export class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
31
+ public emitter = new EventEmitter();
32
+ public events = getSocketEvents(this.emitter);
33
+
34
+ url: string;
35
+ reconnect: number;
36
+ reconnectTime: number;
37
+ auth?: ClientQueryParamsType | string;
38
+ queryParams?: ClientQueryParamsType | string;
39
+ debug: boolean;
40
+ autoConnect: boolean;
41
+
42
+ // Callbacks
43
+ __onOpenCallbacks: OpenCallbackType<Socket<ClientType>, any>[] = [];
44
+ __onCloseCallbacks: CloseCallbackType<Socket<ClientType>, any>[] = [];
45
+ __onReconnectCallbacks: ReconnectCallbackType<Socket<ClientType>>[] = [];
46
+ __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<ClientType>>[] = [];
47
+ __onMessageCallbacks: MessageCallbackType<Socket<ClientType>, any>[] = [];
48
+ __onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
49
+ __onErrorCallbacks: ErrorCallbackType<Socket<ClientType>, any>[] = [];
50
+
51
+ // Config
52
+ client: ClientType;
53
+ loggerManager = new LoggerManager(this);
54
+ appManager = new AppManager();
55
+ queryParamsConfig?: QueryStringifyOptions;
56
+
57
+ // Logger
58
+ logger = this.loggerManager.init("Socket");
59
+
60
+ /**
61
+ * Method to stringify query params from objects.
62
+ */
63
+ queryParamsStringify: StringifyCallbackType = (queryParams) => {
64
+ return stringifyQueryParams(queryParams, this.queryParamsConfig);
65
+ };
66
+
67
+ constructor(public options: SocketConfig<ClientType>) {
68
+ const {
69
+ url,
70
+ auth,
71
+ client,
72
+ queryParams,
73
+ autoConnect,
74
+ reconnect,
75
+ reconnectTime,
76
+ queryParamsConfig,
77
+ queryParamsStringify,
78
+ } = this.options;
79
+ this.url = url;
80
+ this.auth = auth;
81
+ this.queryParams = queryParams;
82
+ this.debug = false;
83
+ this.autoConnect = autoConnect ?? true;
84
+ this.reconnect = reconnect ?? Infinity;
85
+ this.reconnectTime = reconnectTime ?? DateInterval.second * 2;
86
+
87
+ if (queryParamsConfig) {
88
+ this.queryParamsConfig = queryParamsConfig;
89
+ }
90
+ if (queryParamsStringify) {
91
+ this.queryParamsStringify = queryParamsStringify;
92
+ }
93
+
94
+ // Client must be initialized at the end
95
+ this.client = client || (new SocketClient(this) as unknown as ClientType);
96
+ }
97
+
98
+ /**
99
+ * This method enables the logger usage and display the logs in console
100
+ */
101
+ setDebug = (debug: boolean) => {
102
+ this.debug = debug;
103
+ return this;
104
+ };
105
+
106
+ /**
107
+ * Set the logger severity of the messages displayed to the console
108
+ */
109
+ setLoggerSeverity = (severity: SeverityType) => {
110
+ this.loggerManager.setSeverity(severity);
111
+ return this;
112
+ };
113
+
114
+ /**
115
+ * Set the new logger instance to the socket
116
+ */
117
+ setLogger = (callback: (socket: Socket<ClientType>) => LoggerManager) => {
118
+ this.loggerManager = callback(this);
119
+ return this;
120
+ };
121
+
122
+ /**
123
+ * Callbacks
124
+ */
125
+
126
+ /**
127
+ * Triggered when connection is opened
128
+ * @param callback
129
+ * @returns
130
+ */
131
+ onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<ClientType>, Event>) {
132
+ this.__onOpenCallbacks.push(callback);
133
+ return this;
134
+ }
135
+ /**
136
+ * Triggered when connection is closed
137
+ * @param callback
138
+ * @returns
139
+ */
140
+ onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<ClientType>, Event>) {
141
+ this.__onCloseCallbacks.push(callback);
142
+ return this;
143
+ }
144
+
145
+ /**
146
+ * Triggered when connection is getting reconnected
147
+ * @param callback
148
+ * @returns
149
+ */
150
+ onReconnect(callback: ReconnectCallbackType<Socket<ClientType>>) {
151
+ this.__onReconnectCallbacks.push(callback);
152
+ return this;
153
+ }
154
+
155
+ /**
156
+ * Triggered when connection attempts are stopped
157
+ * @param callback
158
+ * @returns
159
+ */
160
+ onReconnectStop(callback: ReconnectStopCallbackType<Socket<ClientType>>) {
161
+ this.__onReconnectStopCallbacks.push(callback);
162
+ return this;
163
+ }
164
+
165
+ /**
166
+ * Triggered when any message is received
167
+ * @param callback
168
+ * @returns
169
+ */
170
+ onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<ClientType>, Event>) {
171
+ this.__onMessageCallbacks.push(callback);
172
+ return this;
173
+ }
174
+
175
+ /**
176
+ * Triggered when any event is emitted
177
+ * @param callback
178
+ * @returns
179
+ */
180
+ onSend<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>) {
181
+ this.__onSendCallbacks.push(callback);
182
+ return this;
183
+ }
184
+
185
+ /**
186
+ * Triggered when we receive error
187
+ * @param callback
188
+ * @returns
189
+ */
190
+ onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<ClientType>, Event>) {
191
+ this.__onErrorCallbacks.push(callback);
192
+ return this;
193
+ }
194
+
195
+ /**
196
+ * ********************
197
+ * Interceptors
198
+ * ********************
199
+ */
200
+
201
+ __modifySend = (emitter: EmitterInstance) => {
202
+ return interceptEmitter(this.__onSendCallbacks, emitter);
203
+ };
204
+
205
+ __modifyResponse = (response: MessageEvent) => {
206
+ return interceptListener(this.__onMessageCallbacks, response, this);
207
+ };
208
+
209
+ /**
210
+ * ********************
211
+ * Creators
212
+ * ********************
213
+ */
214
+
215
+ /**
216
+ * Create event listener
217
+ * @param options
218
+ * @returns
219
+ */
220
+ createListener = <ResponseType>(options: ListenerOptionsType<ClientType>) => {
221
+ return new Listener<ResponseType, ClientType>(this, options as any);
222
+ };
223
+
224
+ /**
225
+ * Create event emitter
226
+ * @param options
227
+ * @returns
228
+ */
229
+ createEmitter = <RequestDataType, ResponseDataType = never>(options: EmitterOptionsType<ClientType>) => {
230
+ if ("isSSE" in this.options) {
231
+ throw new Error("Cannot create emitters for SSE client");
232
+ }
233
+ return new Emitter<RequestDataType, ResponseDataType, ClientType>(this, options as any);
234
+ };
235
+ }
@@ -0,0 +1,33 @@
1
+ import { ClientQueryParamsType, QueryStringifyOptions, StringifyCallbackType } from "@hyper-fetch/core";
2
+
3
+ import { Socket } from "socket";
4
+ import { ServerSentEventsClientOptionsType, WebsocketClientOptionsType } from "client";
5
+ import { EmitterInstance } from "emitter";
6
+
7
+ export type SocketInstance = Socket<any>;
8
+
9
+ export type SocketConfigBaseType<SocketClientType> = {
10
+ url: string;
11
+ client?: SocketClientType;
12
+ auth?: ClientQueryParamsType;
13
+ queryParams?: ClientQueryParamsType | string;
14
+ reconnect?: number;
15
+ reconnectTime?: number;
16
+ autoConnect?: boolean;
17
+ queryParamsConfig?: QueryStringifyOptions;
18
+ queryParamsStringify?: StringifyCallbackType;
19
+ };
20
+
21
+ export type SocketConfig<SocketClientType> =
22
+ | (SocketConfigBaseType<SocketClientType> & { isSSE: true; clientOptions?: ServerSentEventsClientOptionsType })
23
+ | (SocketConfigBaseType<SocketClientType> & {
24
+ clientOptions?: WebsocketClientOptionsType;
25
+ });
26
+
27
+ export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
28
+ export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
29
+ export type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
30
+ export type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
31
+ export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
32
+ export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
33
+ export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
@@ -0,0 +1,43 @@
1
+ import { EmitterInstance } from "emitter";
2
+ import { MessageCallbackType, SendCallbackType, SocketInstance } from "./socket.types";
3
+
4
+ export const getErrorKey = () => "socket_error";
5
+ export const getOpenKey = () => "socket_open";
6
+ export const getCloseKey = () => "socket_close";
7
+ export const getConnectingKey = () => "socket_connecting";
8
+ export const getReconnectingKey = () => "socket_reconnecting";
9
+ export const getReconnectingStopKey = () => "socket_reconnecting_stop";
10
+ export const getListenerEventKey = () => `listener_event`;
11
+ export const getListenerRemoveKey = () => `listener_remove`;
12
+ export const getEmitterEventKey = () => `emitter_event`;
13
+ export const getListenerRemoveByNameKey = (event: string) => `${event}_listener_remove`;
14
+ export const getListenerEventByNameKey = (event: string) => `${event}_listener_event`;
15
+ export const getEmitterEventByNameKey = (event: string) => `${event}_emitter_event`;
16
+
17
+ export const interceptListener = <SocketType extends SocketInstance>(
18
+ interceptors: MessageCallbackType<SocketType, MessageEvent>[],
19
+ response: MessageEvent,
20
+ socket: SocketType,
21
+ ) => {
22
+ let newResponse = response;
23
+ // eslint-disable-next-line no-restricted-syntax
24
+ for (const interceptor of interceptors) {
25
+ newResponse = interceptor(response, socket);
26
+ if (!newResponse) throw new Error("Listener modifier must return data");
27
+ }
28
+
29
+ return newResponse;
30
+ };
31
+
32
+ export const interceptEmitter = <EmitterType extends EmitterInstance>(
33
+ interceptors: SendCallbackType<EmitterType>[],
34
+ emitter: EmitterType,
35
+ ) => {
36
+ let newEmitter = emitter;
37
+ // eslint-disable-next-line no-restricted-syntax
38
+ for (const interceptor of interceptors) {
39
+ newEmitter = interceptor(emitter) as EmitterType;
40
+ if (!newEmitter) throw new Error("Send modifier must return emitter");
41
+ }
42
+ return newEmitter;
43
+ };
@@ -0,0 +1,16 @@
1
+ import { WebsocketClientType } from "client";
2
+ import { Emitter } from "emitter";
3
+ import { Listener } from "listener";
4
+
5
+ // Emitter
6
+
7
+ export type ExtractEmitterOptionsType<T extends Record<keyof WebsocketClientType | string, any>> = T["emitterOptions"];
8
+
9
+ export type ExtractListenerOptionsType<T extends Record<keyof WebsocketClientType | string, any>> =
10
+ T["listenerOptions"];
11
+
12
+ // Listener
13
+
14
+ export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
15
+
16
+ export type ExtractListenerDataType<T> = T extends Emitter<infer D, any, any> ? D : never;
@@ -0,0 +1,2 @@
1
+ export * from "./tuple.types";
2
+ export * from "./extract.types";
@@ -0,0 +1 @@
1
+ export type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
package/tsconfig.json ADDED
@@ -0,0 +1,8 @@
1
+ {
2
+ "extends": "../../tsconfig.json",
3
+ "compilerOptions": {
4
+ "rootDir": "./src",
5
+ "baseUrl": "./src"
6
+ },
7
+ "exclude": ["dist", "__tests__", "jest.config.ts"]
8
+ }