@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.
- package/.eslintrc.json +8 -3
- package/README.md +6 -6
- package/dist/index.d.ts +523 -296
- package/dist/index.js +1246 -0
- package/dist/index.js.map +7 -0
- package/package.json +8 -9
- package/src/adapter/adapter.bindings.ts +128 -101
- package/src/adapter/adapter.ts +231 -0
- package/src/adapter/adapter.types.ts +10 -101
- package/src/adapter/index.ts +4 -4
- package/src/adapter-sse/index.ts +3 -0
- package/src/adapter-sse/sse-adapter.ts +192 -0
- package/src/adapter-sse/sse-adapter.types.ts +6 -0
- package/src/adapter-sse/sse-adapter.utils.ts +77 -0
- package/src/adapter-websockets/index.ts +3 -0
- package/src/adapter-websockets/websocket-adapter.ts +259 -0
- package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
- package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
- package/src/emitter/emitter.ts +60 -102
- package/src/emitter/emitter.types.ts +82 -49
- package/src/index.ts +3 -0
- package/src/listener/listener.ts +34 -49
- package/src/listener/listener.types.ts +69 -17
- package/src/socket/socket.events.ts +147 -112
- package/src/socket/socket.ts +78 -100
- package/src/socket/socket.types.ts +13 -18
- package/src/socket/socket.utils.ts +12 -14
- package/src/types/connect.types.ts +2 -2
- package/src/types/extract.types.ts +43 -10
- package/src/utils/index.ts +3 -0
- package/src/utils/message-event.utils.ts +6 -0
- package/src/utils/socket.errors.ts +48 -0
- package/src/utils/socket.utils.ts +4 -0
- package/tsconfig.json +7 -3
- package/dist/index.cjs.js +0 -853
- package/dist/index.cjs.js.map +0 -7
- package/dist/index.esm.js +0 -833
- package/dist/index.esm.js.map +0 -7
- package/src/adapter/adapter.sse.ts +0 -127
- package/src/adapter/adapter.utils.ts +0 -20
- package/src/adapter/adapter.websocket.ts +0 -187
|
@@ -0,0 +1,231 @@
|
|
|
1
|
+
import {
|
|
2
|
+
defaultMapper,
|
|
3
|
+
DefaultMapperType,
|
|
4
|
+
EmptyTypes,
|
|
5
|
+
QueryParamsMapper,
|
|
6
|
+
QueryParamsType,
|
|
7
|
+
QueryStringifyOptionsType,
|
|
8
|
+
} from "@hyper-fetch/core";
|
|
9
|
+
|
|
10
|
+
import { Socket, SocketInstance } from "socket";
|
|
11
|
+
import { Connector, RemoveListenerCallbackType } from "./adapter.types";
|
|
12
|
+
import { getAdapterBindings } from "./adapter.bindings";
|
|
13
|
+
import { ListenerInstance, ListenerCallbackType } from "listener";
|
|
14
|
+
import { EmitterInstance } from "emitter";
|
|
15
|
+
import { ExtractAdapterExtraType } from "types";
|
|
16
|
+
|
|
17
|
+
export class SocketAdapter<
|
|
18
|
+
Extra = undefined,
|
|
19
|
+
AdapterOptions extends Record<string, any> | EmptyTypes = undefined,
|
|
20
|
+
ListenerOptions extends Record<string, any> | EmptyTypes = undefined,
|
|
21
|
+
EmitterOptions extends Record<string, any> | EmptyTypes = undefined,
|
|
22
|
+
QueryParams extends QueryParamsType | string | EmptyTypes = undefined,
|
|
23
|
+
QueryParamsMapperType extends QueryParamsMapper<any> | DefaultMapperType = DefaultMapperType,
|
|
24
|
+
> {
|
|
25
|
+
public name: string;
|
|
26
|
+
public socket: SocketInstance;
|
|
27
|
+
public defaultExtra?: Extra;
|
|
28
|
+
|
|
29
|
+
public queryParams?: QueryParams;
|
|
30
|
+
public queryParamsConfig?: QueryStringifyOptionsType;
|
|
31
|
+
|
|
32
|
+
/** Config for the query params mapper */
|
|
33
|
+
public unstable_queryParamsMapperConfig: Parameters<QueryParamsMapperType>[1];
|
|
34
|
+
/** Method to get request data and transform them to the required format. */
|
|
35
|
+
public unstable_queryParamsMapper: QueryParamsMapperType = defaultMapper as QueryParamsMapperType;
|
|
36
|
+
|
|
37
|
+
public adapterOptions: AdapterOptions | EmptyTypes;
|
|
38
|
+
public listenerOptions: ListenerOptions | EmptyTypes;
|
|
39
|
+
public emitterOptions: EmitterOptions | EmptyTypes;
|
|
40
|
+
|
|
41
|
+
private getConnector: () => Connector;
|
|
42
|
+
|
|
43
|
+
// State
|
|
44
|
+
public connected = false;
|
|
45
|
+
public connecting = false;
|
|
46
|
+
public reconnectionAttempts = 0;
|
|
47
|
+
public forceClosed = false;
|
|
48
|
+
|
|
49
|
+
// Listeners
|
|
50
|
+
public listeners = new Map<string, Map<ListenerCallbackType<this, any>, VoidFunction>>();
|
|
51
|
+
public listen: (listener: ListenerInstance, callback: ListenerCallbackType<this, any>) => RemoveListenerCallbackType;
|
|
52
|
+
public emit: (emitter: EmitterInstance) => void;
|
|
53
|
+
public connect: () => void;
|
|
54
|
+
public reconnect: () => void;
|
|
55
|
+
public disconnect: () => void;
|
|
56
|
+
|
|
57
|
+
constructor(
|
|
58
|
+
public options: {
|
|
59
|
+
name: string;
|
|
60
|
+
queryParams?: QueryParams;
|
|
61
|
+
defaultConnected?: boolean;
|
|
62
|
+
defaultConnecting?: boolean;
|
|
63
|
+
defaultReconnectionAttempts?: number;
|
|
64
|
+
defaultForceClosed?: boolean;
|
|
65
|
+
},
|
|
66
|
+
) {
|
|
67
|
+
this.name = options.name;
|
|
68
|
+
this.queryParams = options.queryParams;
|
|
69
|
+
|
|
70
|
+
if (options.defaultConnected) {
|
|
71
|
+
this.setConnected(options.defaultConnected);
|
|
72
|
+
}
|
|
73
|
+
if (options.defaultConnecting) {
|
|
74
|
+
this.setConnecting(options.defaultConnecting);
|
|
75
|
+
}
|
|
76
|
+
if (options.defaultReconnectionAttempts) {
|
|
77
|
+
this.setReconnectionAttempts(options.defaultReconnectionAttempts);
|
|
78
|
+
}
|
|
79
|
+
if (options.defaultForceClosed) {
|
|
80
|
+
this.setForceClosed(options.defaultForceClosed);
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
public initialize(socket: SocketInstance) {
|
|
85
|
+
this.socket = socket;
|
|
86
|
+
this.adapterOptions = { ...this.adapterOptions, ...socket.options.adapterOptions };
|
|
87
|
+
|
|
88
|
+
const { listen, emit, connect, reconnect, disconnect } = this.getConnector();
|
|
89
|
+
this.listen = listen;
|
|
90
|
+
this.emit = emit;
|
|
91
|
+
this.connect = connect;
|
|
92
|
+
this.reconnect = reconnect;
|
|
93
|
+
this.disconnect = disconnect;
|
|
94
|
+
|
|
95
|
+
return this;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
public setQueryParams(queryParams: QueryParams) {
|
|
99
|
+
this.queryParams = queryParams;
|
|
100
|
+
return this;
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
public setQueryParamsConfig(queryParamsConfig: QueryStringifyOptionsType) {
|
|
104
|
+
this.queryParamsConfig = queryParamsConfig;
|
|
105
|
+
return this;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
public setDefaultExtra(defaultExtra: Extra) {
|
|
109
|
+
this.defaultExtra = defaultExtra;
|
|
110
|
+
return this;
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
public setOptions(adapterOptions: AdapterOptions | EmptyTypes) {
|
|
114
|
+
this.adapterOptions = adapterOptions;
|
|
115
|
+
return this;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
public setDefaultListenerOptions(listenerOptions: ListenerOptions | EmptyTypes) {
|
|
119
|
+
this.listenerOptions = listenerOptions;
|
|
120
|
+
return this;
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
public setDefaultEmitterOptions(emitterOptions: EmitterOptions | EmptyTypes) {
|
|
124
|
+
this.emitterOptions = emitterOptions;
|
|
125
|
+
return this;
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
public setQueryParamsMapperConfig = <NewQueryParamsMapperConfig extends Parameters<QueryParamsMapperType>[1]>(
|
|
129
|
+
config: NewQueryParamsMapperConfig,
|
|
130
|
+
) => {
|
|
131
|
+
this.unstable_queryParamsMapperConfig = config;
|
|
132
|
+
return this;
|
|
133
|
+
};
|
|
134
|
+
|
|
135
|
+
/**
|
|
136
|
+
* Set the query params mapping function which get triggered before request get sent
|
|
137
|
+
*/
|
|
138
|
+
public setQueryParamsMapper = <NewQueryParamsMapper extends QueryParamsMapper<QueryParams>>(
|
|
139
|
+
queryParamsMapper: NewQueryParamsMapper,
|
|
140
|
+
) => {
|
|
141
|
+
this.unstable_queryParamsMapper = ((queryParams: Parameters<NewQueryParamsMapper>[0]) =>
|
|
142
|
+
queryParamsMapper(
|
|
143
|
+
queryParams,
|
|
144
|
+
this.unstable_queryParamsMapperConfig as Parameters<NewQueryParamsMapper>[1],
|
|
145
|
+
)) as unknown as QueryParamsMapperType;
|
|
146
|
+
return this as unknown as SocketAdapter<
|
|
147
|
+
Extra,
|
|
148
|
+
AdapterOptions,
|
|
149
|
+
ListenerOptions,
|
|
150
|
+
EmitterOptions,
|
|
151
|
+
QueryParams,
|
|
152
|
+
NewQueryParamsMapper
|
|
153
|
+
>;
|
|
154
|
+
};
|
|
155
|
+
|
|
156
|
+
// Listeners
|
|
157
|
+
|
|
158
|
+
public removeListener = ({
|
|
159
|
+
topic,
|
|
160
|
+
callback,
|
|
161
|
+
}: {
|
|
162
|
+
topic: string;
|
|
163
|
+
callback: ListenerCallbackType<
|
|
164
|
+
SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>,
|
|
165
|
+
any
|
|
166
|
+
>;
|
|
167
|
+
}): boolean => {
|
|
168
|
+
const listenerGroup = this.listeners.get(topic);
|
|
169
|
+
if (listenerGroup) {
|
|
170
|
+
const unmount = listenerGroup.get(callback);
|
|
171
|
+
this.socket.events.emitListenerRemoveEvent({ topic });
|
|
172
|
+
listenerGroup.delete(callback);
|
|
173
|
+
unmount?.();
|
|
174
|
+
return true;
|
|
175
|
+
}
|
|
176
|
+
return false;
|
|
177
|
+
};
|
|
178
|
+
|
|
179
|
+
public triggerListeners = ({
|
|
180
|
+
topic,
|
|
181
|
+
data,
|
|
182
|
+
extra,
|
|
183
|
+
}: {
|
|
184
|
+
topic: string;
|
|
185
|
+
data: any;
|
|
186
|
+
extra: ExtractAdapterExtraType<
|
|
187
|
+
SocketAdapter<Extra, AdapterOptions, ListenerOptions, EmitterOptions, QueryParams, QueryParamsMapperType>
|
|
188
|
+
>;
|
|
189
|
+
}) => {
|
|
190
|
+
const listenerGroup = this.listeners.get(topic);
|
|
191
|
+
if (listenerGroup) {
|
|
192
|
+
listenerGroup.forEach((_, action) => {
|
|
193
|
+
action({ data, extra: extra as ExtractAdapterExtraType<this> });
|
|
194
|
+
});
|
|
195
|
+
}
|
|
196
|
+
};
|
|
197
|
+
|
|
198
|
+
// State
|
|
199
|
+
|
|
200
|
+
setConnected = (connected: boolean) => {
|
|
201
|
+
this.connected = connected;
|
|
202
|
+
return this;
|
|
203
|
+
};
|
|
204
|
+
|
|
205
|
+
setConnecting = (connecting: boolean) => {
|
|
206
|
+
this.connecting = connecting;
|
|
207
|
+
return this;
|
|
208
|
+
};
|
|
209
|
+
|
|
210
|
+
setReconnectionAttempts = (reconnectionAttempts: number) => {
|
|
211
|
+
this.reconnectionAttempts = reconnectionAttempts;
|
|
212
|
+
return this;
|
|
213
|
+
};
|
|
214
|
+
|
|
215
|
+
setForceClosed = (forceClosed: boolean) => {
|
|
216
|
+
this.forceClosed = forceClosed;
|
|
217
|
+
return this;
|
|
218
|
+
};
|
|
219
|
+
|
|
220
|
+
// Connector
|
|
221
|
+
|
|
222
|
+
public setConnector = (connector: (bindings: ReturnType<typeof getAdapterBindings<this>>) => Connector) => {
|
|
223
|
+
this.getConnector = () => {
|
|
224
|
+
const bindings = getAdapterBindings<this>(this.socket as Socket<this>);
|
|
225
|
+
|
|
226
|
+
return connector(bindings);
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
return this;
|
|
230
|
+
};
|
|
231
|
+
}
|
|
@@ -1,109 +1,18 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import {
|
|
1
|
+
import { EmitterInstance } from "emitter";
|
|
2
|
+
import { ListenerCallbackType, ListenerInstance } from "listener";
|
|
3
|
+
import type { SocketAdapter } from "./adapter";
|
|
4
4
|
|
|
5
5
|
export type RemoveListenerCallbackType = () => void;
|
|
6
6
|
|
|
7
|
-
export type
|
|
8
|
-
data: D;
|
|
9
|
-
extra: ExtractSocketExtraType<AdapterType>;
|
|
10
|
-
}) => void;
|
|
7
|
+
export type SocketAdapterInstance = SocketAdapter<any, any, any, any, any, any>;
|
|
11
8
|
|
|
12
|
-
export type
|
|
13
|
-
AdapterOptions extends Record<string, any> = never,
|
|
14
|
-
AdapterExtra extends Record<string, any> = Record<never, never>,
|
|
15
|
-
ListenerOptions extends Record<string, any> = never,
|
|
16
|
-
EmitterOptions extends Record<string, any> = never,
|
|
17
|
-
> = (
|
|
18
|
-
socket: Socket<SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>,
|
|
19
|
-
DO_NOT_USE?: {
|
|
20
|
-
adapterOptions?: AdapterOptions;
|
|
21
|
-
adapterExtra?: AdapterExtra;
|
|
22
|
-
listenerOptions?: ListenerOptions;
|
|
23
|
-
emitterOptions?: EmitterOptions;
|
|
24
|
-
},
|
|
25
|
-
) => {
|
|
26
|
-
open: boolean;
|
|
27
|
-
reconnectionAttempts: number;
|
|
28
|
-
listeners: Map<string, Map<ListenerCallbackType<SocketAdapterInstance, any>, VoidFunction>>;
|
|
29
|
-
listen: (
|
|
30
|
-
listener: Listener<any, any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>,
|
|
31
|
-
callback: ListenerCallbackType<
|
|
32
|
-
SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>,
|
|
33
|
-
any
|
|
34
|
-
>,
|
|
35
|
-
) => RemoveListenerCallbackType;
|
|
36
|
-
removeListener: (endpoint: string, callback: (...args: any) => void) => void;
|
|
37
|
-
emit: (
|
|
38
|
-
eventMessageId: string,
|
|
39
|
-
emitter: EmitterInstance,
|
|
40
|
-
ack?: EmitterAcknowledgeType<any, SocketAdapterType<AdapterOptions, AdapterExtra, ListenerOptions, EmitterOptions>>,
|
|
41
|
-
) => void;
|
|
42
|
-
connecting: boolean;
|
|
9
|
+
export type Connector = {
|
|
43
10
|
connect: () => void;
|
|
44
11
|
reconnect: () => void;
|
|
45
12
|
disconnect: () => void;
|
|
13
|
+
listen: (
|
|
14
|
+
listener: ListenerInstance,
|
|
15
|
+
callback: ListenerCallbackType<SocketAdapterInstance, any>,
|
|
16
|
+
) => RemoveListenerCallbackType;
|
|
17
|
+
emit: (emitter: EmitterInstance) => void;
|
|
46
18
|
};
|
|
47
|
-
|
|
48
|
-
export type SocketAdapterInstance = SocketAdapterType<any, any, any, any>;
|
|
49
|
-
|
|
50
|
-
// Extractors
|
|
51
|
-
|
|
52
|
-
export type ExtractSocketOptionsType<T> = T extends SocketAdapterType<infer O, any, any, any> ? O : never;
|
|
53
|
-
export type ExtractSocketExtraType<T> = T extends SocketAdapterType<any, infer E, any, any> ? E : never;
|
|
54
|
-
export type ExtractListenerOptionsType<T> = T extends SocketAdapterType<any, any, infer O, any> ? O : never;
|
|
55
|
-
export type ExtractEmitterOptionsType<T> = T extends SocketAdapterType<any, any, any, infer E> ? E : never;
|
|
56
|
-
|
|
57
|
-
export type ExtractUnionSocket<
|
|
58
|
-
Adapter extends SocketAdapterInstance,
|
|
59
|
-
Values extends {
|
|
60
|
-
adapterOptions?: any;
|
|
61
|
-
adapterExtra?: any;
|
|
62
|
-
listenerOptions?: any;
|
|
63
|
-
emitterOptions?: any;
|
|
64
|
-
},
|
|
65
|
-
> = Extract<
|
|
66
|
-
Adapter,
|
|
67
|
-
SocketAdapterType<
|
|
68
|
-
Values["adapterOptions"],
|
|
69
|
-
Values["adapterExtra"],
|
|
70
|
-
Values["listenerOptions"],
|
|
71
|
-
Values["emitterOptions"]
|
|
72
|
-
>
|
|
73
|
-
> extends SocketAdapterInstance
|
|
74
|
-
? Extract<
|
|
75
|
-
Adapter,
|
|
76
|
-
SocketAdapterType<
|
|
77
|
-
Values["adapterOptions"],
|
|
78
|
-
Values["adapterExtra"],
|
|
79
|
-
Values["listenerOptions"],
|
|
80
|
-
Values["emitterOptions"]
|
|
81
|
-
>
|
|
82
|
-
>
|
|
83
|
-
: never;
|
|
84
|
-
|
|
85
|
-
// Options
|
|
86
|
-
|
|
87
|
-
export type SSEAdapterOptionsType = {
|
|
88
|
-
eventSourceInit?: EventSourceInit;
|
|
89
|
-
};
|
|
90
|
-
|
|
91
|
-
export type WSAdapterOptionsType = {
|
|
92
|
-
protocols?: string[];
|
|
93
|
-
pingTimeout?: number;
|
|
94
|
-
pongTimeout?: number;
|
|
95
|
-
heartbeatMessage?: string;
|
|
96
|
-
heartbeat?: boolean;
|
|
97
|
-
};
|
|
98
|
-
|
|
99
|
-
export type WSMessageType = {
|
|
100
|
-
id: string;
|
|
101
|
-
endpoint: string;
|
|
102
|
-
data: string;
|
|
103
|
-
};
|
|
104
|
-
|
|
105
|
-
// Adapters
|
|
106
|
-
|
|
107
|
-
export type SocketData<D = any> = { endpoint: string; data: D };
|
|
108
|
-
export type WebsocketAdapterType = SocketAdapterType<WSAdapterOptionsType, MessageEvent<SocketData>>;
|
|
109
|
-
export type SSEAdapterType = SocketAdapterType<SSEAdapterOptionsType, MessageEvent<SocketData>>;
|
package/src/adapter/index.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
export * from "./adapter.websocket";
|
|
2
|
-
export * from "./adapter.sse";
|
|
3
|
-
export * from "./adapter.types";
|
|
4
|
-
export * from "./adapter.utils";
|
|
5
1
|
export * from "./adapter.bindings";
|
|
2
|
+
export * from "./adapter.types";
|
|
3
|
+
export * from "./adapter";
|
|
4
|
+
|
|
5
|
+
export type SocketData<D = any> = { topic: string; payload: D };
|
|
@@ -0,0 +1,192 @@
|
|
|
1
|
+
/* eslint-disable @typescript-eslint/no-use-before-define */
|
|
2
|
+
import { QueryParamsType, stringifyQueryParams } from "@hyper-fetch/core";
|
|
3
|
+
|
|
4
|
+
import { ExtendListener, ListenerCallbackType, ListenerInstance } from "listener";
|
|
5
|
+
import { SocketData } from "adapter";
|
|
6
|
+
import { SocketAdapter } from "adapter/adapter";
|
|
7
|
+
import { getServerSentEventsAdapter } from "./sse-adapter.utils";
|
|
8
|
+
import { SSEAdapterOptionsType } from "./sse-adapter.types";
|
|
9
|
+
import { getSocketUrl, parseMessageEvent } from "../utils";
|
|
10
|
+
import { getSocketError } from "../utils/socket.errors";
|
|
11
|
+
import { Socket } from "socket";
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* -------------------------------------------
|
|
15
|
+
* Websocket
|
|
16
|
+
* -------------------------------------------
|
|
17
|
+
*/
|
|
18
|
+
|
|
19
|
+
export type ServerSentEventsAdapterType = SocketAdapter<
|
|
20
|
+
MessageEvent<any>,
|
|
21
|
+
SSEAdapterOptionsType,
|
|
22
|
+
undefined,
|
|
23
|
+
undefined,
|
|
24
|
+
QueryParamsType | string,
|
|
25
|
+
typeof stringifyQueryParams
|
|
26
|
+
>;
|
|
27
|
+
|
|
28
|
+
export const ServerSentEventsAdapter = (): ServerSentEventsAdapterType =>
|
|
29
|
+
new SocketAdapter<
|
|
30
|
+
MessageEvent<any>,
|
|
31
|
+
SSEAdapterOptionsType,
|
|
32
|
+
undefined,
|
|
33
|
+
undefined,
|
|
34
|
+
QueryParamsType | string,
|
|
35
|
+
typeof stringifyQueryParams
|
|
36
|
+
>({
|
|
37
|
+
name: "sse",
|
|
38
|
+
})
|
|
39
|
+
.setQueryParamsMapper(stringifyQueryParams)
|
|
40
|
+
.setConnector(
|
|
41
|
+
({
|
|
42
|
+
socket,
|
|
43
|
+
adapter,
|
|
44
|
+
getQueryParams,
|
|
45
|
+
onConnect,
|
|
46
|
+
onReconnect,
|
|
47
|
+
onDisconnect,
|
|
48
|
+
onListen,
|
|
49
|
+
onConnected,
|
|
50
|
+
onDisconnected,
|
|
51
|
+
onError,
|
|
52
|
+
onEvent,
|
|
53
|
+
}) => {
|
|
54
|
+
let sse: ReturnType<typeof getServerSentEventsAdapter> | undefined;
|
|
55
|
+
|
|
56
|
+
const autoConnect =
|
|
57
|
+
typeof socket.adapter.adapterOptions?.autoConnect === "boolean"
|
|
58
|
+
? socket.adapter.adapterOptions?.autoConnect
|
|
59
|
+
: true;
|
|
60
|
+
|
|
61
|
+
const connect = () => {
|
|
62
|
+
const url = getSocketUrl(socket.url, getQueryParams());
|
|
63
|
+
const enabled = onConnect();
|
|
64
|
+
if (!enabled) {
|
|
65
|
+
return Promise.resolve(false);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
sse?.clearListeners();
|
|
69
|
+
sse?.close();
|
|
70
|
+
|
|
71
|
+
const eventSource = getServerSentEventsAdapter(url, adapter.adapterOptions);
|
|
72
|
+
sse = eventSource;
|
|
73
|
+
|
|
74
|
+
// Make sure we picked good environment
|
|
75
|
+
if (!eventSource) {
|
|
76
|
+
return Promise.resolve(false);
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
// Reconnection timeout
|
|
80
|
+
const timeout = setTimeout(() => {
|
|
81
|
+
reconnect();
|
|
82
|
+
}, socket.reconnectTime);
|
|
83
|
+
|
|
84
|
+
/**
|
|
85
|
+
* Mount listeners
|
|
86
|
+
*/
|
|
87
|
+
|
|
88
|
+
eventSource.addEventListener("open", () => {
|
|
89
|
+
clearTimeout(timeout);
|
|
90
|
+
onConnected();
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
eventSource.addEventListener("error", (event) => {
|
|
94
|
+
const error = getSocketError(event);
|
|
95
|
+
|
|
96
|
+
onError({ error: new Error(error) });
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
eventSource.addEventListener("message", (newEvent: MessageEvent<SocketData>) => {
|
|
100
|
+
const { topic, data, event } = parseMessageEvent(newEvent);
|
|
101
|
+
|
|
102
|
+
onEvent({ topic, data, extra: event });
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
return new Promise((resolve) => {
|
|
106
|
+
if (eventSource.readyState === EventSource.OPEN) {
|
|
107
|
+
resolve(true);
|
|
108
|
+
adapter.setConnected(true);
|
|
109
|
+
adapter.setConnecting(false);
|
|
110
|
+
return;
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
// Promise lifecycle
|
|
114
|
+
const resolveConnected = () => {
|
|
115
|
+
resolve(true);
|
|
116
|
+
eventSource.removeEventListener("open", resolveConnected);
|
|
117
|
+
};
|
|
118
|
+
const resolveError = () => {
|
|
119
|
+
resolve(false);
|
|
120
|
+
eventSource.removeEventListener("error", resolveError);
|
|
121
|
+
};
|
|
122
|
+
|
|
123
|
+
eventSource.addEventListener("open", resolveConnected, { disableCleanup: true });
|
|
124
|
+
eventSource.addEventListener("error", resolveError, { disableCleanup: true });
|
|
125
|
+
});
|
|
126
|
+
};
|
|
127
|
+
|
|
128
|
+
const disconnect = async (): Promise<boolean> => {
|
|
129
|
+
if (!sse) {
|
|
130
|
+
adapter.setConnected(false);
|
|
131
|
+
adapter.setConnecting(false);
|
|
132
|
+
return Promise.resolve(true);
|
|
133
|
+
}
|
|
134
|
+
const currentSse = sse;
|
|
135
|
+
const promise = new Promise<boolean>((resolve) => {
|
|
136
|
+
if (currentSse.readyState === EventSource.CLOSED) {
|
|
137
|
+
resolve(true);
|
|
138
|
+
adapter.setConnected(false);
|
|
139
|
+
adapter.setConnecting(false);
|
|
140
|
+
return;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
const resolveDisconnected = () => {
|
|
144
|
+
resolve(true);
|
|
145
|
+
currentSse.removeEventListener("error", resolveDisconnected);
|
|
146
|
+
};
|
|
147
|
+
currentSse.addEventListener("error", resolveDisconnected, { disableCleanup: true });
|
|
148
|
+
});
|
|
149
|
+
|
|
150
|
+
onDisconnect();
|
|
151
|
+
currentSse.close();
|
|
152
|
+
onDisconnected();
|
|
153
|
+
|
|
154
|
+
return promise;
|
|
155
|
+
};
|
|
156
|
+
|
|
157
|
+
const reconnect = () => {
|
|
158
|
+
onReconnect({ disconnect, connect });
|
|
159
|
+
};
|
|
160
|
+
|
|
161
|
+
const listen = (
|
|
162
|
+
listener: ExtendListener<ListenerInstance, { socket: Socket<ServerSentEventsAdapterType> }>,
|
|
163
|
+
callback: ListenerCallbackType<ServerSentEventsAdapterType, any>,
|
|
164
|
+
) => {
|
|
165
|
+
return onListen({ listener, callback });
|
|
166
|
+
};
|
|
167
|
+
|
|
168
|
+
const emit = async () => {
|
|
169
|
+
throw new Error("Cannot emit events in SSE adapter");
|
|
170
|
+
};
|
|
171
|
+
|
|
172
|
+
// Initialize
|
|
173
|
+
|
|
174
|
+
if (autoConnect) {
|
|
175
|
+
connect();
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
socket.appManager.events.onOnline(() => {
|
|
179
|
+
if (autoConnect && !adapter.connected) {
|
|
180
|
+
connect();
|
|
181
|
+
}
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
return {
|
|
185
|
+
connect,
|
|
186
|
+
reconnect,
|
|
187
|
+
disconnect,
|
|
188
|
+
listen,
|
|
189
|
+
emit,
|
|
190
|
+
};
|
|
191
|
+
},
|
|
192
|
+
);
|
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
import { EmptyTypes } from "@hyper-fetch/core";
|
|
2
|
+
|
|
3
|
+
import { SSEAdapterOptionsType } from "./sse-adapter.types";
|
|
4
|
+
|
|
5
|
+
export const getServerSentEventsAdapter = (url: string, adapterOptions: SSEAdapterOptionsType | EmptyTypes) => {
|
|
6
|
+
/** istanbul ignore next */
|
|
7
|
+
try {
|
|
8
|
+
/** istanbul ignore next */
|
|
9
|
+
if (!window?.EventSource) return null;
|
|
10
|
+
} catch (error) {
|
|
11
|
+
return null;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
class HyperFetchEventSource extends EventSource {
|
|
15
|
+
public listeners: Map<
|
|
16
|
+
(...args: any[]) => any,
|
|
17
|
+
{ type: keyof EventSourceEventMap; listener: (...args: any[]) => void; options: any }
|
|
18
|
+
> = new Map();
|
|
19
|
+
|
|
20
|
+
// eslint-disable-next-line @typescript-eslint/no-useless-constructor
|
|
21
|
+
constructor(socketUrl: string, eventSourceInit?: EventSourceInit) {
|
|
22
|
+
super(socketUrl, eventSourceInit);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
onopen: EventSource["onopen"] = (...args) => {
|
|
26
|
+
this.listeners.forEach(({ type, listener }) => {
|
|
27
|
+
if (type === "open") {
|
|
28
|
+
listener(...args);
|
|
29
|
+
}
|
|
30
|
+
});
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
onerror: EventSource["onerror"] = (...args) => {
|
|
34
|
+
this.listeners.forEach(({ type, listener }) => {
|
|
35
|
+
if (type === "error") {
|
|
36
|
+
listener(...args);
|
|
37
|
+
}
|
|
38
|
+
});
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
onmessage: EventSource["onmessage"] = (...args) => {
|
|
42
|
+
this.listeners.forEach(({ type, listener }) => {
|
|
43
|
+
if (type === "message") {
|
|
44
|
+
listener(...args);
|
|
45
|
+
}
|
|
46
|
+
});
|
|
47
|
+
};
|
|
48
|
+
|
|
49
|
+
addEventListener = <K extends keyof EventSourceEventMap>(
|
|
50
|
+
type: K,
|
|
51
|
+
listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
|
|
52
|
+
options?: boolean | (AddEventListenerOptions & { disableCleanup?: boolean }),
|
|
53
|
+
): void => {
|
|
54
|
+
super.addEventListener(type, listener, options);
|
|
55
|
+
this.listeners.set(listener, { type, listener, options });
|
|
56
|
+
};
|
|
57
|
+
|
|
58
|
+
removeEventListener = <K extends keyof EventSourceEventMap>(
|
|
59
|
+
type: K,
|
|
60
|
+
listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
|
|
61
|
+
options?: boolean | EventListenerOptions,
|
|
62
|
+
): void => {
|
|
63
|
+
super.removeEventListener(type, listener, options);
|
|
64
|
+
this.listeners.delete(listener);
|
|
65
|
+
};
|
|
66
|
+
|
|
67
|
+
clearListeners = () => {
|
|
68
|
+
this.listeners.forEach(({ type, listener, options }) => {
|
|
69
|
+
if (!options?.disableCleanup) {
|
|
70
|
+
this.removeEventListener(type, listener, options);
|
|
71
|
+
}
|
|
72
|
+
});
|
|
73
|
+
};
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
return new HyperFetchEventSource(url, adapterOptions?.eventSourceInit);
|
|
77
|
+
};
|