type TypedEventTarget<EventMap extends object> = {
new (): IntermediateEventTarget<EventMap>;
};
interface IntermediateEventTarget<EventMap> extends EventTarget {
addEventListener<K extends keyof EventMap>(
type: K,
callback: (
event: EventMap[K] extends Event ? EventMap[K] : never
) => EventMap[K] extends Event ? void : never,
options?: boolean | AddEventListenerOptions
): void;
addEventListener(
type: string,
callback: EventListenerOrEventListenerObject | null,
options?: EventListenerOptions | boolean
): void;
removeEventListener<K extends keyof EventMap>(
type: K,
callback: (
event: EventMap[K] extends Event ? EventMap[K] : never
) => EventMap[K] extends Event ? void : never,
options?: boolean | AddEventListenerOptions
): void;
removeEventListener(
type: string,
callback: EventListenerOrEventListenerObject | null,
options?: EventListenerOptions | boolean
): void;
}
/*!
* Reconnecting WebSocket
* by Pedro Ladaria <pedro.ladaria@gmail.com>
* https://github.com/pladaria/reconnecting-websocket
* License MIT
*/
declare class ErrorEvent extends Event {
message: string;
error: Error;
constructor(error: Error, target: any);
}
declare class CloseEvent extends Event {
code: number;
reason: string;
wasClean: boolean;
constructor(
code: number | undefined,
reason: string | undefined,
target: any
);
}
interface WebSocketEventMap {
close: CloseEvent;
error: ErrorEvent;
message: MessageEvent;
open: Event;
}
type Options = {
WebSocket?: any;
maxReconnectionDelay?: number;
minReconnectionDelay?: number;
reconnectionDelayGrowFactor?: number;
minUptime?: number;
connectionTimeout?: number;
maxRetries?: number;
maxEnqueuedMessages?: number;
startClosed?: boolean;
debug?: boolean;
debugLogger?: (...args: any[]) => void;
};
type UrlProvider = string | (() => string) | (() => Promise<string>);
type ProtocolsProvider =
| null
| string
| string[]
| (() => string | string[] | null)
| (() => Promise<string | string[] | null>);
type Message = string | ArrayBuffer | Blob | ArrayBufferView;
declare const ReconnectingWebSocket_base: TypedEventTarget<WebSocketEventMap>;
declare class ReconnectingWebSocket extends ReconnectingWebSocket_base {
private _ws;
private _retryCount;
private _uptimeTimeout;
private _connectTimeout;
private _shouldReconnect;
private _connectLock;
private _binaryType;
private _closeCalled;
private _messageQueue;
private _debugLogger;
protected _url: UrlProvider;
protected _protocols?: ProtocolsProvider;
protected _options: Options;
constructor(
url: UrlProvider,
protocols?: ProtocolsProvider,
options?: Options
);
static get CONNECTING(): number;
static get OPEN(): number;
static get CLOSING(): number;
static get CLOSED(): number;
get CONNECTING(): number;
get OPEN(): number;
get CLOSING(): number;
get CLOSED(): number;
get binaryType(): BinaryType;
set binaryType(value: BinaryType);
/**
* Returns the number or connection retries
*/
get retryCount(): number;
/**
* The number of bytes of data that have been queued using calls to send() but not yet
* transmitted to the network. This value resets to zero once all queued data has been sent.
* This value does not reset to zero when the connection is closed; if you keep calling send(),
* this will continue to climb. Read only
*/
get bufferedAmount(): number;
/**
* The extensions selected by the server. This is currently only the empty string or a list of
* extensions as negotiated by the connection
*/
get extensions(): string;
/**
* A string indicating the name of the sub-protocol the server selected;
* this will be one of the strings specified in the protocols parameter when creating the
* WebSocket object
*/
get protocol(): string;
/**
* The current state of the connection; this is one of the Ready state constants
*/
get readyState(): number;
/**
* The URL as resolved by the constructor
*/
get url(): string;
/**
* Whether the websocket object is now in reconnectable state
*/
get shouldReconnect(): boolean;
/**
* An event listener to be called when the WebSocket connection's readyState changes to CLOSED
*/
onclose: ((event: CloseEvent) => void) | null;
/**
* An event listener to be called when an error occurs
*/
onerror: ((event: ErrorEvent) => void) | null;
/**
* An event listener to be called when a message is received from the server
*/
onmessage: ((event: MessageEvent) => void) | null;
/**
* An event listener to be called when the WebSocket connection's readyState changes to OPEN;
* this indicates that the connection is ready to send and receive data
*/
onopen: ((event: Event) => void) | null;
/**
* Closes the WebSocket connection or connection attempt, if any. If the connection is already
* CLOSED, this method does nothing
*/
close(code?: number, reason?: string): void;
/**
* Closes the WebSocket connection or connection attempt and connects again.
* Resets retry counter;
*/
reconnect(code?: number, reason?: string): void;
/**
* Enqueue specified data to be transmitted to the server over the WebSocket connection
*/
send(data: Message): void;
private _debug;
private _getNextDelay;
private _wait;
private _getNextProtocols;
private _getNextUrl;
private _connect;
private _handleTimeout;
private _disconnect;
private _acceptOpen;
private _handleOpen;
private _handleMessage;
private _handleError;
private _handleClose;
private _removeListeners;
private _addListeners;
private _clearTimeouts;
}
export {
CloseEvent,
ErrorEvent,
type Message,
type Options,
type ProtocolsProvider,
type UrlProvider,
type WebSocketEventMap,
ReconnectingWebSocket as default
};
