@hyper-fetch/sockets 6.0.0 → 7.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +6 -6
  3. package/dist/index.d.ts +523 -296
  4. package/dist/index.js +1246 -0
  5. package/dist/index.js.map +7 -0
  6. package/package.json +8 -9
  7. package/src/adapter/adapter.bindings.ts +128 -101
  8. package/src/adapter/adapter.ts +231 -0
  9. package/src/adapter/adapter.types.ts +10 -101
  10. package/src/adapter/index.ts +4 -4
  11. package/src/adapter-sse/index.ts +3 -0
  12. package/src/adapter-sse/sse-adapter.ts +192 -0
  13. package/src/adapter-sse/sse-adapter.types.ts +6 -0
  14. package/src/adapter-sse/sse-adapter.utils.ts +77 -0
  15. package/src/adapter-websockets/index.ts +3 -0
  16. package/src/adapter-websockets/websocket-adapter.ts +259 -0
  17. package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
  18. package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
  19. package/src/emitter/emitter.ts +60 -102
  20. package/src/emitter/emitter.types.ts +82 -49
  21. package/src/index.ts +3 -0
  22. package/src/listener/listener.ts +34 -49
  23. package/src/listener/listener.types.ts +69 -17
  24. package/src/socket/socket.events.ts +147 -112
  25. package/src/socket/socket.ts +78 -100
  26. package/src/socket/socket.types.ts +13 -18
  27. package/src/socket/socket.utils.ts +12 -14
  28. package/src/types/connect.types.ts +2 -2
  29. package/src/types/extract.types.ts +43 -10
  30. package/src/utils/index.ts +3 -0
  31. package/src/utils/message-event.utils.ts +6 -0
  32. package/src/utils/socket.errors.ts +48 -0
  33. package/src/utils/socket.utils.ts +4 -0
  34. package/tsconfig.json +7 -3
  35. package/dist/index.cjs.js +0 -853
  36. package/dist/index.cjs.js.map +0 -7
  37. package/dist/index.esm.js +0 -833
  38. package/dist/index.esm.js.map +0 -7
  39. package/src/adapter/adapter.sse.ts +0 -127
  40. package/src/adapter/adapter.utils.ts +0 -20
  41. package/src/adapter/adapter.websocket.ts +0 -187
@@ -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 { EmitterAcknowledgeType, EmitterInstance } from "emitter";
2
- import { Listener } from "listener";
3
- import { Socket } from "socket";
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 ListenerCallbackType<AdapterType extends SocketAdapterInstance, D> = (response: {
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 SocketAdapterType<
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>>;
@@ -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,3 @@
1
+ export * from "./sse-adapter";
2
+ export * from "./sse-adapter.types";
3
+ export * from "./sse-adapter.utils";
@@ -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,6 @@
1
+ // Options
2
+
3
+ export type SSEAdapterOptionsType = {
4
+ eventSourceInit?: EventSourceInit;
5
+ autoConnect?: boolean;
6
+ };
@@ -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
+ };
@@ -0,0 +1,3 @@
1
+ export * from "./websocket-adapter";
2
+ export * from "./websocket-adapter.types";
3
+ export * from "./websocket-adapter.utils";